1. 8

    There are plenty of things to criticize Google for – and this page does list a few valid points – but a lot of these points are … I’m not entirely sure how to accurately describe them without resorting to some rather negative and unfriendly adjectives.

    Calling parental controls “Google censorship”? Yeah nah, that’s just off the deep end lads.

    1. 7

      Calling parental controls “Google censorship”? Yeah nah, that’s just off the deep end lads.

      That one crossed the line for me as well. I wish the FSF would stay a bit more objective and stick to the facts. It actively harms their credibility to pad lists like this with such items. It sure as hell means I won’t link this page to someone in order to convince them.

      1. 6

        That one crossed the line for me as well. I wish the FSF would stay a bit more objective and stick to the facts. It actively harms their credibility to pad lists like this with such items. It sure as hell means I won’t link this page to someone in order to convince them.

        The FSF is more concerned with how easily this kind of functionality can be turned into a tool for mass-censorship. They are also concerned about the fact that parents don’t trust their kids anymore, what this technology means for us as human beings and how easily masses of people can be manipulated by this.

        As for the mass-manipulation, they certainly have a point there and I would definitely link to this page to show people how much this stuff can influence them and their decisions.

        1. 5

          how easily this kind of functionality can be turned into a tool for mass-censorship

          Is the FSF also against firewalls? TCP wrappers? Ad blockers (Ad censorship?) And a long list of technology that can be used for this purpose?

          A lot of tools and tech can be subverted for nefarious purposes. I don’t really buy these kind of “sliding slope”-kind of arguments.

          concerned about the fact that parents don’t trust their kids anymore

          It’s not about trust, it’s about your 5-year old not stumbling on “ISIS soldier beheads infidel”, or “two young teens get assfucked by 8 men”, etc. All of that is … really easy to do.

          Either way, if they wanted to discus the finer points of the ethics of parental control over your children’s lives – a tricky topic with no easy answers – then fair enough. But that’s not what this page does: it just shouts “Google Censorship!!!!!11”

          1.  

            I can agree that the position as a bullet point could never neatly fit within a bullet point. I also feel that any firewall, tcp-wrapper, or ad blocker that blocked content on a moral basis, where only one moral perspective was represented is at best problematic. This gets more problematic as we consider that this filter would be the primary option for most people on the most used services. What happens when those positions deviate strongly from our views of right and wrong, but still prevents the content we definitely don’t want our children to see. Most parents would reluctantly use the filter that protects their children at cost.

            1.  

              Imagine if software were written to not be hackable by default. Imagine that software were not susceptible to viruses. We wouldn’t need firewalls. We wouldn’t need CFAA.

              Similarly, imagine if software were written to not run unknown code without consent by default. We wouldn’t need ad blockers.

              A lot of the software that we use in daily life is software which works around the corporate and aristocratic controls which our society attempts to place upon us. It would be nice if we didn’t have to write so much code to work around faulty code written by bad actors with poor incentives.

            2.  

              Why should the free software foundation have a say about parenting?

              1.  

                Why should the free software foundation have a say about parenting?

                It’s not about having a say in parenting. It’s about informing parents about the types of manipulation kids and parents are subject too. It’s also about making parents aware of the fact that a simple “gadget” or “technology” can severely damage the trust a child has in it’s parent or caretaker. With these kinds of tools that is a real concern, because kids also have secrets for their parents.

                1.  

                  The FSF has long held many moral positions, as it is common for non-profits to do. I would argue that it’s important for the FSF to respond to corporations attempting to shape our children’s minds. Without that, software definitely will not be free for long. Whether or not you agree with parental censorship (most do to some extent, as do I to an extent), I would be surprised to hear that you think that we should leave it to a third party who may or may not have motivated reasoning, and not our children’s best interest in mind.

            3.  

              Most of the “parental controls” I’ve seen from Google are highly opinionated about what is and is not appropriate for children, and do not allow the parent to meaningfully choose what things are and are not appropriate. The “parental controls” thus far I have seen, by taking control away from the parent are therefore fundamentally censorship whether intentional or not. Now you might agree with those positions, but agreeing with a censorship doesn’t mean it isn’t censorship. The positions they choose in the future may not align with your values. They may encourage content you oppose, and ban content you support. This is already the present climate on youtube, so it’s not a slippery slope. A lot of the “children’s videos” are genuinely very messed up, and a lot of the “banned content” is wholesome.

              1.  

                Most of the “parental controls” I’ve seen from Google are highly opinionated about what is and is not appropriate for children, and do not allow the parent to meaningfully choose what things are and are not appropriate

                They do not support a parent in choosing. They are in no position to disallow it.

                by taking control away from the parent are therefore fundamentally censorship whether intentional or not

                They don’t take control away from the parent though. The parent is perfectly free to not use googles (patently crap, in the case of youtube kids) filter.

                In general life, I’m a language descriptivist; whatever language gets the point across is fine. This, however is a technical forum. Words mean things, and diluting those meanings to score a point undermines technical communication in a way that actively sabotages building working software.

                This kind of semantic shenanigans (where a word to describe a genuine threat like ‘censorship’ get repurposed to also describe “software that isn’t sufficiently configurable for my tastes”) is actively harmful.

                1.  

                  I genuinely disagree that these are semantic shenanigans. When dealing with children, and software that specifically claims to support child users, characterizing the issue as “software that isn’t sufficiently configurable to my tastes” is a really bold position. Censorship is not some boogeyman that can only be done by the federal government. It also is not some universal crime against society. It is however something that warrants concern when it shapes the kinds of content that children are exposed to on a daily basis. Especially when parents are faced with a binary decision to follow google’s social mores or not. You may feel it is as simple as not using their services, however problems are rarely so simple.

                2.  

                  I agree about this. As a parent, my opinions about what are suitable for my children are quite different than the consensus that Google uses. I am slightly more lenient about sex, much less lenient about violence, and am most concerned about brain-rotting addictive content (see YouTube Kids) that Google thinks is totally okay. I would really like to have flexible parental controls; IMO this is not about tastes, but about values.

                  1.  

                    I am slightly more lenient about sex, much less lenient about violence, and am most concerned about brain-rotting addictive content (see YouTube Kids) that Google thinks is totally okay

                    It sounds like our values align fairly closely on this, but other people have different values, and all of us have the choice to use a different solutions/product than Google’s.

                3.  

                  I for one didn’t bother clicking the link because I already knew what kind of wankfest it was going to be.

                1. 6

                  So that example is essentially just rm dir/*.ext? Or find dir -name '*.ext' -delete (not clear to me if your version is recursive or not)? I’m not so convinced your JS version is that much better to be honest.

                  1. 3

                    Yep, that’s exactly what it does! For simple examples like this, you’ll often find the shell version to be more straightforward, but as soon as what you’re trying to achieve is more tortuous (with branching, user input, etc) I think Tasklemon allows the whole logic to be laid out in a much more readable way.

                    1. 2

                      Right; it may be worthwhile to think of an example that better illustrates the strengths of your library. I don’t disagree that larger shell scripts can become unwieldy (I even wrote an entire article about it a while ago), but that doesn’t automatically mean that any alternative is better.

                  1. 20

                    Sad :-( I still think Mercurial far better meets the needs of most people, and that the chief reasons for git’s popularity are that Linus Torvalds wrote it, GitHub, and that Linus Torvalds wrote it.

                    That said, I did end up switching from BitBucket/mercurial to GitHub/git a few years ago, simply because it’s the more pragmatical thing to do and I was tired of paying the “mercurial penalty” in missed patches and the like. I wrote a thing about it a few ago: https://arp242.net/git-hg.html

                    1. 6

                      I never particularly liked git and find it unintuitive, too.

                      I wouldn’t consider myself a git poweruser. But whenever I had to work with alternatives I got the feeling that they’re just inferior versions of git. Yeah, maybe the usage was a bit more intuitive, but all of them seemed to lack things that I’d consider really basic (bisecting - hg has that, but e.g. svn has not - and shallow copying - not avaible in hg - are examples what I often miss).

                      1. 5

                        Why do you think hg is better for most people? I honestly find it vastly more complex to use.

                        1. 15

                          The hg cli is light years ahead of git in terms of intuitiveness.

                          1. 6

                            I’d say it’s years behind ;)

                            1. 10

                              How long have you been using Mercurial? I find most people who dislike Mercurial’s UI, are mainly coming from years of experience with Git. I disliked Mercurial at first as well, but after a few years of forced usage it clicked. Now I appreciate how simple and well composed it is and get frustrated whenever I need to look up some arcane Git flag on StackOverflow.

                              In general, I’d say you need several years experience with both Git and Mercurial before you can draw a fair comparison.

                              1. 3

                                I used mercurial for about 2 years before using git.

                                1.  

                                  Sorry if my post came across a bit accusatory (not my intent). In that case I guess to each their own :).

                                2.  

                                  but after a few years of forced usage it clicked.

                                  I’m pretty sure that git clicked for me in a much shorter timeframe.

                                  1.  

                                    Me too, but I know many (otherwise perfectly competent engineers) 5-10 years in who still don’t get it and aren’t likely to.

                                3. 9

                                  I’m going to strongly disagree. I’ve used git intensively and I find Mercurial to be a well-designed delight. I’ve run across features that Mercurial supports flawlessly, with a nice UI, and Git requires a hacky filter-branch that takes hours to run and doesn’t even behave correctly.

                                  IMO, a lot of the badness in projects is down to Git badness. it doesn’t scale and people feel compelled to break things down into tiny sub-projects.

                                  The only reason Git is winning anything is GitHub’s support of it.

                                  1.  

                                    The only reason Git is winning anything is GitHub’s support of it.

                                    Why then was github ever used in the first place? Kind of a strange proposition.

                              2. 8

                                You find mercurial more complex to use than git? That’s an… unusual view, to say the least. The usual recitation of benefits goes something like this

                                • Orthogonal functionality in hg mostly has orthogonal commands (compare git commit, which does a half-dozen essentially unrelated different things).
                                • hg has a somewhat more uniform CLI (compare git branch -a, git remote -v, git stash list).
                                • hg either lacks or hides a bunch of purportedly-inessential and potentially confusing git functionality (off the top of my head, partial commits aren’t baked into the flow a la git’s index/staging area; and rebasing and history rewriting are hidden behind an extension).

                                I personally prefer git, but not because I think it’s easier or simpler; I’m more familiar with it, and I find many of those purportedly-inessential functions to be merely purportedly, not actually, inessential.

                                1. 5

                                  One more thing I like about mercurial that the default set of commands is enough for >90% of people, and that everything else is “hidden” in extensions. This is a very different approach than git’s “kitchen-sink” approach, which gives people 170 commands (vs. Mercurial’s 50, most of which also have much fewer options/switches than git).

                                  Git very much feels like “bloatware” compared to Mercurial.

                                  1.  

                                    I used git for many years, and then mercurial (at FB) ever since we switched over. The cli interface for mercurial is definitely more sensible, crecord is delightful, and overall it was fine. But I was never able to build a mental model of how mercurial actually worked. git has a terrible interface, but it’s actually really simple underneath.

                                    1.  

                                      I didn’t think that underneath they were different enough to matter much. What differences do you mean? I guess there’s git’s remote tracking stuff. Generally, it seems like they differ in how to refer to and track commits and topological branches, locally and remotely. (IMHO, neither has great mechanisms for all the things I want to do.) Mercurial is slightly more complex with the manifest, git is more complex with the staging area that feels absolutely critical until you don’t have it (by using hg), at which time you wonder why anyone bothers with it. I’m a heavier hg user than git user, but that’s about all I can come up with.

                                    2.  

                                      You find mercurial more complex to use than git?

                                      I actually found – in a professional shop – mercurial far more complex to use. Now, the fact is that mercurials core – vanilla hg is IMHO absolutely without doubt vastly superior to git. Git keeps trying to make the porcelain less painful (including a release just a bit ago) – but I still think it is ages behind.

                                      The problem is – I never used vanilla mercurial in a professional environment. Not once. It was always mercurial++ (we used $X extension and $Y extension and do it like $Z) which meant even if I knew hg, I felt painfully inexperienced because I didn’t know mq, share, attic, collapse, evolve, and more… not to mention both the bigger shops I worked with using mercurial has completely custom workflow extensions. I suspect part of this was just the ease of writing mercurial extensions, and part of it was wanting to fall into a flow they knew (mq, collapse). But, regardless of how we got there, at each place I effectively felt like I had to relearn how to use the version control system entirely.

                                      As opposed to git, wherein I can just drop in and work from day one. It might be less clean, it might be more finicky and enable things like history rewriting by default. But at the end of the day, the day I start, I know how to generally function.

                                      I am curious how Mercurial would have faired if instead of shipping default extensions you had to turn on – if they had just baked a little more functionality, to try to cover the 80% of what most shops wanted (not needed, I think most could have gotten by with what vanilla mercurial had) – if the shop to shop transition would have been easier.

                                      1.  

                                        mq, I think, is responsible for many of the “mercurial is too complicated” complaints people have. Evolve, if it ever stabilized and ships with core hg would really enable some killer capabilities. Sadly for social and technical reasons it’s perpetually in beta.

                                      2. 1

                                        whoa, no index? Admittedly I didnt really use index as intended for several years, but now its an important part of my workflow.

                                        1.  

                                          In Mercurial, commits are so much easier to make and manipulate (split, fold, move), that you don’t miss the index. The index in git is just a limited special cased “commit”.

                                          1.  

                                            The index in git is just a limited special cased “commit”.

                                            I disagree.

                                            The index is a useful way to say “these lines of code are ready to go”. If you are making a big commit, it can be helpful to add changes in logical blocks to the index as you go. Then the diff is not polluted with stuff you know is already fine to commit.

                                            You might say, “why not just make those changes their own commits, instead of trying to do one big commit?” That’s a valid question if you are talking about a 200 line commit or similar, but sometimes the “big” commit is only 50 lines. Instead of making a bunch of one line or few line commits, its helpful to “git add” small chunks, then commit at the end.

                                            1.  

                                              You can as well amend to a commit instead of adding to the index.

                                              1.  

                                                True, but all thats doing is bastardizing the commit process. If you are committing a one line change, just to rebase minutes or hours later, thats not a commit.

                                                Rebase to me is for commits that were intended to be commits, but later I decided it would be better to squash or change the history. The index is for changes that are never meant to be a full commit on their own.

                                                1.  

                                                  Having a distinction between draft and published phases in mercurial I think makes it easier to rewrite WIP work. There’s also a number of UI affordances for it. I don’t miss the index using mercurial. There’s also academic user interface research that shows the index is a big conceptual barrier for new users.

                                                  1.  

                                                    There’s also academic user interface research that shows the index is a big conceptual barrier for new users.

                                                    this isnt really a valid point in my opinion. some concepts are just difficult. if some goal can be achieved in a simpler way i am on board, but I am not a fan of removing useful features because they are hard to understand.

                                                    1.  

                                                      But the point is the index is hard to understand and unnecessary.

                                                      There’s no need to have a “commit process”. Just commit whatever you want and rewrite/amend it for as long as you want. As long as your commits are drafts, this is fine.

                                                      Is the problem the word “commit”? Does it sound too much like commitment?

                                                      There’s no need to have two separate ways to record changes, an index, and a commit, each with different degrees of commitments. This is multiplying entities beyond necessity.

                                                      1.  

                                                        That’s your opinion. The index is quite useful to me. I’d rather make a proper commit once it’s ready, not hack together a bunch of one line commits after the fact.

                                                        1.  

                                                          The index is a commit. Why have two separate ways of storing the same sort of thing?

                                                          Also, it’s not my opinion that it’s hard to understand and unnecessary; it’s the result of usability studies:

                                                          https://spderosso.github.io/oopsla16.pdf

                                                          You’re also not “hacking together” anything after the fact. There’s no more hacking together after the fact whether you use git amend (hypothetically) or git add. Both of those mean, “record additional changes”.

                                                          1.  

                                                            It seems you have a fundamental misunderstanding of the difference between add and commit. Commit requires a commit message.

                                                            1.  

                                                              This isn’t a useful distinction. You can also create commits with empty commit messages in both git and Mercurial.

                                                              With both git and Mercurial you can also amend commit messages after the fact. The index in git could well be implemented as a commit with an empty commit message that you keep amending and you wouldn’t notice the difference at all.

                                                              1.  

                                                                you keep amending and you wouldn’t notice the difference at all.

                                                                yeah, you would. again it seems that you either dont know git, or havent used it in some time. when you amend a commit, you are prompted to amend the message as well. another facet that doesnt exist with git add, because add doesnt involve a message.

                                                                if you wish to contort git internals to suit your agenda thats fine, but git add has perfectly valid use cases.

                                                                1.  

                                                                  you are prompted to amend the message as well.

                                                                  This is UI clutter unrelated to the underlying concepts. You can get around that with wrappers and aliases. I spoke of a hypothetical git amend above that could be an alias that avoids prompting for a commit message.

                                                                  Don’t git users like to say how the UI is incidental? That once you understand the data structures, everything else is easy? The UI seems to have locked you into believing the index is a fundamentally necessary concept, but it’s not. It’s an artifact of the UI.

                                                                  1.  

                                                                    The UI seems to have locked you into believing the index is a fundamentally necessary concept, but it’s not.

                                                                    Nothing has locked me into believing its a necessary concept. Its not necessary. In fact, for about 7 years I didnt use the index in any meaningful way.

                                                                    I think what you are missing is that Im not compelled to use it because its the default workflow, I am compelled to use it because its useful. It helps me accomplish work more smoothly than I did previously, when I would just make a bunch of tiny commits because I didnt understand the point of the index, as you still dont.

                                                                    The argument could be made to move the index into an option, like somehow make commit only the default workflow. Im not sure what that would look like with Git, but I dont think its a good idea. It would just encourage people to make a bunch of smaller commits with meaningless commit messages.

                                                              2.  

                                                                You have a set of things you want to accomplish. With git, you have N+1 concepts/features/tools to work with. With hg, you have N (because you drop the index). That means you have to expand your usage of the remaining N.

                                                                Specifically, since you no longer have this extra index concept, you now expand commits to cover the scenarios you need. Normally, you’d make an initial commit and then amend a piece at a time (probably with the interactive curses hunk selector, which is awesome.) If you’re unsure about some pieces, or you have multiple things going on that you’d like to end up in separate commits, you can always make a series of microcommits and then selectively collapse them later. (In practice, it’s even easier than this, because of the absorb extension. But never mind that.)

                                                                Yes, those microcommits need commit messages. They don’t need to be good ones, because they’re temporary until you squash them out of existence. I usually use a one word tag to specify which of the separate final commits they belong to. (If you don’t have separate final commits, you may as well amend, in which case no messages are needed.)

                                                                …or on the other hand, maybe mercurial ends up with N+1 concepts too, because phases really help in keeping things separate. As I understand it, one reason git users love the index is because it keeps rapidly changing, work in progress stuff separate from mostly set in stone commits. Phases perform the same purpose, but more flexibly, and the concepts are more orthogonal so they compose better. In my opinion.

                                      3.  

                                        Mercurial was actually my first DVCS, and like you I ended up switching to git not out of a sense that it was technically better, just more pragmatic. For me, the change is more of a mixed bag, though. It is definitely the case that Mercurial’s UI is worlds better, and revsets in particular are an amazing feature that I sorely miss, but when I made the switch I found that the way git handles branches was much more intuitive to me than Mercurial’s branch/bookmark system, and that the affordances around selectively editing commit histories were very much worth the risk in terms of being able to manage the narrative of a project’s history in a way that makes it more legible to others. Ultimately, I found that git’s advantages outweighed its downsides for my use case, since learning its UI idiosyncrasies was a one-time cost and since managing branches is a much more common occurrence for me than using revsets. That said, I think this is a really unfortunate development.

                                        1. 2

                                          I occasionally convert people’s git repos to hg for my use. Stubborn like that.

                                        1. 10

                                          End of an era, I suppose. There’s no such thing as a healthy monoculture, just monocultures that haven’t found their blight yet.

                                          1. 33

                                            According to that Stack Overflow survey there are plenty of popular alternatives, such as “ZIP file back-ups”, “Copying and pasting files to network shares”, and “I don’t use version control”.

                                            1. 18

                                              Did the ever popular “Final FINAL Copy 2” make it in? That’s got to be the number one version control system, right?

                                              1. 9

                                                My first programming job was like that. I was working as a repair tech at a computer shop, at some point they needed someone to clean up the intranet, and that someone was me.

                                                First thing I did was set up svn and get rid of all the “foo.orig”, “foo.orig2”, etc directories. This was trickier as it might seem as some of the projects were being served from those .orig2 dirs.

                                                All was going well, and then half a year later the guy who had been doing this asked me if knew what happened to the “cms.orig” directory. After I told him I deleted it he said he had been storing the company outings photos there for the last 15 years. By the time we discovered it was too late to recover from backup, so … all lost.

                                                I still don’t understand why you would store pictures in a deeply nested subdir of an otherwise unused cms.orig …. 🤨 from what I heard he ditched svn and went back to his “system” after I left.

                                            2. 13

                                              Well, just to play a devil’s advocate… Some things are so good exactly because they are ubiquitous. Like Unicode, for example. Or POSIX. They have their flaws for sure, but they made writing interoperable software much easier.

                                              There are already other tools that work with the same repository format as the Torvalds’ git. Maybe git format becoming the standard repo format is a good thing after all. No one has to use the reference implementation if they prefer different UI and abstractions.

                                              1. 14

                                                Maybe git format becoming the standard repo format is a good thing after all.

                                                No, it’s definitely not. It doesn’t scale. The git “API” is literally the local filesystem. Microsoft has valiantly hacked the format into functioning at scale with VFS for Git, but the approach is totally bananas.

                                                How does it work?

                                                VFS for Git virtualizes the filesystem beneath your Git repository so that Git tools see what appears to be a normal repository when, in fact, the files are not actually present on disk. VFS for Git only downloads files as they are needed.

                                                VFS for Git also manages Git’s internal state so that it only considers the files you have accessed, instead of having to examine every file in the repository. This ensures that operations like status and checkout are as fast as possible.

                                                - vfsforgit.org

                                                Microsoft had to implement an entire virtual filesystem that, through smoke and mirrors, tricks git to behave sanely. More details in this GVFS architecture overview.

                                                1. 4

                                                  Isn’t the same true for Mercurial and every other DVCS in existence?

                                                  1. 17

                                                    No. Git’s remote repository API is nothing more than a specialized rsync implementation (git-send-pack and git-receive-pack).

                                                    Mercurial uses a semantic API for exchanging changes with the server. It doesn’t need local files in the same way git does. That opens up a lot of doors for scaling large repositories, because you can implement optimizations in the client, protocol, and server.

                                                    For git repos, where local filesystem operations are the protocol, there really is no alternative to Microsoft’s smoke and mirrors, virtualize the world approach. You’d have to just reimplement git, which defeats the point.

                                                    1. 1

                                                      Ah, that is interesting. Thanks for the information, I should look into the way mercurial actually works.

                                                      1. 3

                                                        If you’re curious about the actual on-disk formats (which should be irrelevant, as hg tries to compartmentalise them), you can read about Mercurial’s internals.

                                                  2. 4

                                                    I don’t see anything wrong with git using the local file system API.

                                                    There are multiple implementations of such file systems – Linux, FreeBSD, OS X, Minix, etc. git works fine on all those systems, and the code is portable AFAICT.

                                                    1. 8

                                                      So, I personally love how git transparently exposes its internal data structures for direct manipulation by the user. It gives you tons of power and freedom. Back when I used git, I considered it just as much a development tool as my editor.

                                                      But that transparency is problematic for scaling. To the point where you really do need to implement a virtual remote filesystem tailored for git to support huge repos. Whether you like git or not, that’s bananas.

                                                      1. 5

                                                        There’s nothing bananas about that: scaling is a feature and it’s not surprising that you need more code/engineering to scale. It would be surprising if you didn’t!

                                                        To make a very close analogy, two companies I worked at used Perforce (the proprietary VCS). At one company we used it out of the box, and it worked great. Thousands of companies use Perforce like this, and Perforce is a very profitable company because as a result.

                                                        The second company (Google) also used Perforce out of the box. Then we needed to scale more, so we wrote a FUSE-based VFS (which I imagine the git VFS is very similar to). That doesn’t mean Perforce is “bananas”. It works for 99% of companies.

                                                        It’s just designed for a certain scale, just like git is. Scale requires a lot of tradeoffs, often higher latency, decreased throughput, etc. git seems to have made all the right tradeoffs for its targeted design space. That it succeeded beyond the initial use case is a success story, not an indication of problems with its initial design.


                                                        Also, I don’t see any evidence that Mercurial reached the same scale. It probably has different problems – you don’t really know until you try it. I heard some teams were working on scaling Mercurial quite awhile ago [1], but I’m not sure what happened.

                                                        https://engineering.fb.com/core-data/scaling-mercurial-at-facebook/

                                                        1. 4

                                                          Then we needed to scale more, so we wrote a FUSE-based VFS

                                                          I currently work at Google. CitC has nothing to do with Piper performance, it’s more about the utility of sharing your workspace, both between dev machines and tools (desktop, cloudtop, cider, critique), as well as blaze.

                                                          (which I imagine the git VFS is very similar to).

                                                          Not at all. The git “protocol” is filesystem operations. Microsoft made VFS for Git because they need to intercept filesystem operations to interface with the git toolchain. Perforce and Mercurial have actual remote APIs, git does not.

                                                          That doesn’t mean Perforce is “bananas”. It works for 99% of companies.

                                                          I don’t think Perforce is bananas. I don’t think git is bananas either. I specifically think “git format becoming the standard repo format” is NOT a good thing. The git toolchain and the repo format are inseparable, leading to Microsoft’s bananas implementation of a scalable git server. Clever and impressive, but bananas.

                                                          1. 2

                                                            What I’m reading from your comments is: “If only git had decoupled its repo format and push/pull protocol, then it would be more scalable”.

                                                            I don’t think that’s true. You would just run into DIFFERENT scalability limits with different design decisions. For example: Perforce and Mercurial don’t share that design decision, as you say, but they still have scalability limits. Those designs just have different bottlenecks.

                                                            Designing for scale you don’t have is an antipattern. If literally the only company that has to use a git VFS is Microsoft, then that’s a fantastic tradeoff!!!

                                                            IMO Google’s dev tools are a great example of the tradeoff. They suffer from scalability. They scale and solve unique problems, but are slow as molasses in the common case (speaking from my experience as someone who worked both on the dev tools team and was a user of those tools for 11 years)

                                                            1.  

                                                              I don’t think that’s true. You would just run into DIFFERENT scalability limits with different design decisions.

                                                              Git was probably strongly tied to the filesystem because it was made in 2005 (Pentium 4 era) for a lower-performance scenario by someone who understood the Linux filesystem better than high-performance, distributed applications. It worked for his and their purposes of managing their one project at their pace. Then, wider adoption and design inertia followed.

                                                              It’s 2019. Deploying new capabilities backwards compatible with the 2005 design requires higher, crazier efforts with less-exciting results delivered than better or more modern designs.

                                                              1. 1

                                                                “If only git had decoupled its repo format and push/pull protocol, then it would be more scalable”.

                                                                It would be easier to scale. When the simplest and easiest way to scale genuinely is implementing a client-side virtual filesystem to intercept actions performed by git clients, that’s bananas. To be clear, VFS for Git is more than a simple git-aware network filesystem, there’s some gnarly smoke and mirrors trickery to make it actually work. The git core code is so tightly coupled to the file format, there’s little else you could do, especially if don’t want to break other tooling using libraries like libgit2 or jgit.

                                                                Designing for scale you don’t have is an antipattern.

                                                                Designing tightly coupled components with leaky abstractions is an antipattern. Mercurial supports Piper at Google through a plugin. Doing the same with git just isn’t possible, there’s no API boundary to work with.

                                                        2. 2

                                                          To the best of my knowledge it still uses the intricate knowledge of filesystem behaviour to avoid (most?) fsync calls — and the behaviour it expects is ext3 (which is better at preserving operation order in case of crash than most other filesystems).

                                                          I actually had a hard poweroff during/just after commit corrupt a git repository.

                                                          So, in a way, the API it actually expects is often not provided…

                                                          1. 1

                                                            Do you mean its reliance on atomic rename when managing refs? Or some other behavior?

                                                            1.  

                                                              I would hope that atomic renames are actually expected from a fullu-featured POSIX FS (promised by rename manual page etc).

                                                              But Git also assumes some ordering of file content writes without using fsync.

                                                              1.  

                                                                Renames are only atomic with respect to visibility in a running filesystem, not crash safety, though. So I guess it’s not surprising you’ve seen corruption on crash.

                                                                I’ve been trying to find a way to run a small-scale HA Git server at work — as far as I can tell the only viable option is to replace the whole backend as a unit (e.g., GitHub DGit/Spokes, GitLab’s Gitaly plans). Both GitHub and GitLab started by replicating at a lower level (drbd and NFS, respectively), but moved on. I can say from experience that GlusterFS doesn’t provide whatever Git requires, either.

                                                  1. 2

                                                    The first example doesn’t work with the current version of PyYAML - the specific use of function application was disabled some time ago, and yaml.load() logs a noisy deprecation warning telling users to use yaml.safe_load() instead.

                                                    https://github.com/yaml/pyyaml/wiki/PyYAML-yaml.load(input)-Deprecation

                                                    1. 2

                                                      As I read that, this will just print a warning and still work: “in PyYAML version 5.1, you will get a warning, but the function will still work”?

                                                      Sidenote: one of the ideas I’ve had for a long time is to analyse GitHub with Google BigQuery to try and find exploits for this; I’ll bet you’ll find a few. Unfortunately using the BigQuery UI is about as much fun as smashing your toes against the bedside table, so I never made much progress with it.

                                                      1. 1

                                                        Using !!python/object/apply:os.system with PyYAML version 5.1 will raise an error.

                                                        Using yaml.load(...) with PyYAML version 5.1 will trigger a warning (unless you specify the Loader argument).

                                                        Some examples and the output they create on my machine: https://gist.github.com/borntyping/27e4529b8ac17c1ad9a7a72369525365

                                                    1. 3

                                                      Turns out there have been quite some additions to Vim in 2019 and 2018, but it’s really hard to extract that information from the commit messages and Vim doesn’t keep a ChangeLog :-/

                                                      This only lists the most useful user-facing changes, it’s not a complete list. I may have missed a few items though (since there were many commits to go through) so feel free to open an issue or PR for that.

                                                      1. 3

                                                        Edit: the new version only loads in Chromium and not Firefox; seems some sort of A/B testing thing?

                                                        I’m confused, because if I go to Google images it seems pretty much the same as I remember it, and as your screenshot? Am I seeing a different version of Google images, or am I missing what this extension does?

                                                        1. 6

                                                          The number of times I’d wished I had this feature on Travis.

                                                          Instead you just end up blindly pushing changes to the branch in the hope that it works :P

                                                            1. 3

                                                              Only on Travis-ci.com (the paid version), and not Travis-ci.org (the free version).

                                                              1. 4

                                                                sr.ht is also a paid service, right?

                                                                1. 4

                                                                  It’s up to you whether to pay or run the exact same free software on your own infra.

                                                                  1. 2

                                                                    Is it easy to run on your own? That’s kind of cool. I may pay them anyway but still run it myself.

                                                                    1. 8

                                                                      https://man.sr.ht/installation.md

                                                                      Reach out to the mailing list if you run into trouble :)

                                                                      1. 1

                                                                        Wow, cool! Thanks :)

                                                                    2. 1

                                                                      You can also run travis-ci.org on your own infra (I currently do this) but there isn’t a lot of info about it.

                                                                  2. 3

                                                                    The trick is that for public repos, you have to email support: https://docs.travis-ci.com/user/running-build-in-debug-mode/#enabling-debug-mode

                                                                    1. 1

                                                                      Weird… I guess that they’re trying to prevent wasted containers by adding manual process in the middle?

                                                                      1. 2

                                                                        It’s a security risk, especially for public repos.

                                                                        1. 2

                                                                          Eeeek, that’s rough. builds.sr.ht’s SSH access uses the SSH keys we already have on your account for git authentication et al.

                                                                          1. 1

                                                                            You get that from Github, too. But I also think it doesn’t help, because GH projects are liberal with adding people to orgs/repos and while they cam be grouped, there’s no way to assign structures roles. GH as an identity provider is mediocre at best.

                                                                          2. 1

                                                                            Like, in terms of things which they may do in the shells, DDoSing by creating too many, etc? They use your SSH key from GitHub to prevent others from SSHing in, right?

                                                                            1. 4

                                                                              They use your SSH key from GitHub to prevent others from SSHing in, right?

                                                                              Not AFAIR. It gives a temporary login/password in the build log (which is public). And anyone who logs in can see the unencrypted secrets (e.g. API keys used for pushing to GitHub).

                                                                              1. 1

                                                                                oooooooh… yipes. Super dangerous. CircleCI uses SSH keys to improve on this.

                                                                      2. 1

                                                                        Aren’t they doing some funky reorganization to eliminate the split? I haven’t looked closely so I might be wrong.

                                                                      3. 2

                                                                        I guess I’ve just been too cheap to pay then ;)

                                                                      4. 1

                                                                        This feature is on Travis, but their new configuration API is so excruciatingly painful and lacking of reasonable documentation that it fails to help when it’s really needed.

                                                                        1. 1

                                                                          With Gitlab you can debug CI stages on your machine by starting a local Gitlab Runner.

                                                                        1. 8

                                                                          My commenting solution is:

                                                                          Mail me at martin@arp242.net or create a GitHub issue for feedback, questions, etc.

                                                                          Seems to work fairly well. People email me, anyway.

                                                                          Stuff also ends up on Lobsters, HN, Reddit, etc, which I link if the discussions are worthwhile.

                                                                          Personally I’m not too keen on the “comments on everything” model. I much prefer high-effort commentary/discussion, rather than “quick comments”. I also prefer to integrate valid/reasonable feedback in the article itself, rather than having it sit in a comment at the bottom.

                                                                          1. 6

                                                                            That doesn’t achieve the same goal though. Comment systems allow readers to interact with the author and other readers. E-mailing the author only allows interaction with the author.

                                                                            1. 1

                                                                              You can do that with the GitHub comments and Lobsters/HN/Reddit discussions. There’s also stuff like https://utteranc.es to integrate GitHub comments directly on a (static) website.

                                                                            2. 5

                                                                              Agreed. I’ll probably end up doing something like that.

                                                                              Nice article here, btw: https://arp242.net/censorship.html

                                                                            1. 1

                                                                              I am happy with anything that takes a little bit away from Google’s stranglehold on web analytics, something I rant about from time to time. Personally, I am against third-party trackers altogether but if they have to exist then yours looks like a pretty good deal.

                                                                              Interestingly, the domain www.goatcounter.com is blocked by my work’s firewall; I don’t even want to know why.

                                                                              1. 1

                                                                                against third-party trackers

                                                                                It’s not really a “tracker”, though. It just counts which pages get visited, similar to the “visitor counters” in the web of old. Hence the name: GoatCounter, and not “GoatAnalytics” or some such, and why I avoided the terms “tracker” and “analytics” as much as possible.

                                                                                Or, to give a real-world analogy, it’s simply counting how many people walk in front of your house.

                                                                              1. -4

                                                                                That “bestasciitable” site isn’t great, for the sole reason the table isn’t the first thing I see, centre of frame. The table is also really really big. Attention lost, website closed.

                                                                                1. 18

                                                                                  Ehm, okay. That’s … rather off-topic here? But there’s a “hide” button and it’ll remember in localStorage.

                                                                                  You might also want to reconsider your choice of words in delivering feedback because quite frankly, you could’ve been a lot more friendly. I spent my spare time making that in the hopes that maybe, perhaps, it will be useful to others. If it’s not for you, then that’s fine. If you think it could be better in some way, great! I’d love to hear about it. But no need to be abrasive about it.

                                                                                  Crudely put, I don’t understand why some people in the open source community feel the need to constantly shit all over other members at the drop of a hat. What goal did you hope to achieve with your comment? How did you expect it to be received? Right now it is serving no goal as it contains practically no actionable criticism, and I can assure you it’s not received well.

                                                                                  I strongly urge you to consider your attitude, and how it is received, because right now the only effect it has is making my day a bit worse and me spending 10 minutes writing this reply.

                                                                                  1. 1

                                                                                    I wasn’t trying to shit all over your project, sorry. The table is great, I thought I put that in my message, I must’ve deleted it when moving text around. It probably would’ve made my comment sound less harsh, it wasn’t trying to be. Just when people open asciitable.com they get the ascii table, in full view, in the middle of the page (the whole thing usually fits in one page); and it’s an image, so you can open it in a smaller tab or on your desktop if you need to. The design is very “Don’t make me think”, which is what people are usually looking for.

                                                                                    1. 3

                                                                                      That’s okay; we all make mistakes and it’s hard to communicate by text anyway.

                                                                                      Especially the “Attention lost, website closed” sounds rather abrasive, IMHO. A better comment would have been something along the lines of:

                                                                                      Bit off-topic, but that “bestasciitable” could be better: the table isn’t the first thing I see, centre of frame. The table is also really really big.

                                                                                      Even less words, too!

                                                                                      As a side-note, I tend to write these messages in PMs a lot on Lobsters (e.g. when I have problems with someone’s sites, especially if it’s not directly related to what they’re writing about). It’s a good reminder for myself that I’m writing to an actual person, and sometimes feedback is better received in private anyway. When I first joined Lobsters I was like “why do I need PM?” but I’ve learned to love it.

                                                                                      Just when people open asciitable.com they get the ascii table, in full view, in the middle of the page (the whole thing usually fits in one page); and it’s an image, so you can open it in a smaller tab or on your desktop if you need to. The design is very “Don’t make me think”, which is what people are usually looking for.

                                                                                      Yeah, that’s fair enough. I actually went through a few design cycles where the table was on top and the description below that. I eventually opted for the “hide” link which is remembered accros visits, but maybe I’ll change it in the future.

                                                                                      My goal was mainly to answer stuff like: https://www.reddit.com/r/vim/comments/cqvbvs/how_to_map_ctrl_number_looking_for_help/ewzt3ig/ – I started writing the website after a similar question, wanted to link to a good ASCII table, and … couldn’t really find one.

                                                                                1. 2

                                                                                  Curious to hear what motivated this. You say there were no good solutions for your requirements, so I’m curious what those requirements were/are?

                                                                                  1. 2

                                                                                    I wrote a rather detailed comparison several months ago of all solutions I could find (before I started work on this), but then I accidentally rm’d that and never bothered re-doing it 🤦 From the top of my head:

                                                                                    • Many add large amounts of JavaScript. For example I believe Matomo (formerly PiWik) adds 120k or something; I believe Google Analytics is even larger. Not just a lot to download (comparatively to the rest of the site) but also a lot to execute, that can go wrong, etc.

                                                                                    • Hard to use UI: my main question I had about my personal website was “who linked to it”, so I can follow HN conversations and whatnot. I found it surprisingly hard to get this information out of Matomo’s UI.

                                                                                    • In general, I’d like an UI/frontend that doesn’t suck. I don’t know why so many of these modern web apps are such a pain to use.

                                                                                    • I have little need to persistently track people (that is, recognize you as a repeat visitor when you come back next week), and don’t want to display annoying faux-consent banners. Pretty much all existing solutions track people (Fathom is one of the few that doesn’t).

                                                                                    • I tried Fathom originally (self-hosted) but there were a few pain points. I would have preferred to contribute to Fathom, but they don’t seem open to contributions, so 🤷

                                                                                  1. 2

                                                                                    I too was interested in Fathom Analytics, but the reason it is not active is because they decided to completely rewrite Fathom for version 2 and make that new version proprietary. When I asked them to reconsider, they said no.

                                                                                    1. 2

                                                                                      Oh, I didn’t know about that. I find the complaints about lack of contributions rather strange, since they’re just ignoring people’s PRs and issues :-/

                                                                                    1. 2

                                                                                      How good is it at separating humans from goats^W bots?

                                                                                      Also, would it be against GDPR to collect aggregate data on user-agents etc., basically increase a counter when this or that user agent is seen? Just the page visit data is useful, but it’s hard to satisfy one’s curiosity regarding the visitors and answer development directions questions like “should I improve the CSS for mobile users?”, “is anyone still using IE?” etc.

                                                                                      1. 4

                                                                                        RE GDPR, aggregate data is generally quite safe (anything you definitely can’t link it to a person is safe - so e.g. IP address is riskier as there’s a reasonable chance there’s only one user).

                                                                                        Also worth bearing in mind that the goal of GDPR is compliance, not revenue- I’m unaware of any case where a fine has been issued without a “please comply or we’ll fine you” letter being ignored.

                                                                                        1. 1

                                                                                          It checks the User-Agent header, which is an external library. It seems to work fairly well. This is also exactly the same library/method that Fathom uses btw.

                                                                                          Just the page visit data is useful, but it’s hard to satisfy one’s curiosity regarding the visitors and answer development directions questions like “should I improve the CSS for mobile users?”, “is anyone still using IE?” etc.

                                                                                          Yeah, the User-Agent header is already stored for every visit. It’s just not processed and displayed yet. It should be added soon.

                                                                                        1. 24

                                                                                          I don’t know @arp242, but recently when I asked how to do something on the Vi Stack Exchange, he said “hm, you can’t do that” and then landed a patch in Vim to implement the feature I was asking for. So it seems safe to say that he’s a friendly person and an asset to the community.

                                                                                          1. 5

                                                                                            Hah, I just did that because I wanted it myself, too. But I’m glad that it’s appreciated :-)

                                                                                          1. 9

                                                                                            Congratulations on shipping, how exciting for you!

                                                                                            I would remove the Personal / $3 tier and instead offer a 14 day trial period that does not require a credit card. The $30 Business price is in the ballpark. Consumers don’t buy services, businesses don’t want to bother with anything that costs less than the morning coffee. IMO.

                                                                                            1. 4

                                                                                              And you could easily add a $99/mo Enterprise tier which promises GDPR compliance. It might be exactly the same as your Business tier; all they are buying is the assurance it’s compliant and your willingness to deal with that headache.

                                                                                              1. 2

                                                                                                The entire GDPR doesn’t even apply right now as no personal data is collected at all. This might change in the future (although it’s a good selling point, IMO), but right now I’m not sure what promising “GDPR compliance” would entail?

                                                                                                I would remove the Personal / $3 tier and instead offer a 14 day trial period that does not require a credit card. The $30 Business price is in the ballpark. Consumers don’t buy services, businesses don’t want to bother with anything that costs less than the morning coffee. IMO.

                                                                                                The reason I added that right now there are surprisingly few options outside of Google analytics that are in an acceptable price range for consumers (basically, none). If there was a service like this for $3/month I probably would have paid it, instead of making this. But maybe that’s just me…

                                                                                                I should probably make it a bit clearer that it’s for personal use, only.

                                                                                                1. 6

                                                                                                  To be fair, the worrying about what “promising GDPR compliance” is what you’re charging the extra $69 for. It may be nothing, but you took the time to worry about it.

                                                                                                  1. 3

                                                                                                    I might be wrong but I believe you’re still required to respond to GDPR queries (e.g. “No, we don’t have any data on you”). Might be straightforward but someone has to respond to that email.

                                                                                                2. 2

                                                                                                  As a counterpoint, I think a simple service like this is great for personal users, but if you are a business you might want more features?

                                                                                                  1. 1

                                                                                                    It looks like the value proposition is similar to Fathom and Simple Analytics so you can use their pricing as a benchmark as well.

                                                                                                  1. 4

                                                                                                    Do you have any transcripts/articles for your videos? To be honest, I’m not very likely to sit down and watch a 15 minute video unless it looks very very interesting, and very few videos like this do.

                                                                                                    1. 3

                                                                                                      I do for this one. It came from an article I wrote a couple of years ago. https://programmingzen.com/pitfalls-when-learning-to-program/

                                                                                                    1. 1

                                                                                                      I love this and have already stuck it on my site on a trial basis. Not much gets me to change my Content Security Policy but you have won me over.

                                                                                                      1. 2

                                                                                                        Thanks, you’re probably the first :-) Let me know if you have any problems, or if there’s anything missing.

                                                                                                      1. 2

                                                                                                        the Fetch API can replace jQuery’s Ajax functions

                                                                                                        Except that it won’t work for 7% of your visitors, which I consider to be a pretty significant number (imagine a store turning away 7% of its customer base!)

                                                                                                        1. 2

                                                                                                          You’d probably just polyfill it, then? It’s easy to do. I wouldn’t consider it a blocker for ditching jQuery :)

                                                                                                          1. 1

                                                                                                            You’d probably just polyfill it, then

                                                                                                            Isn’t that essentially what jQuery is? Besides, jQuery does more than just Ajax (and if you don’t use that part you can make a custom build without ajax).

                                                                                                            It’s easy to do

                                                                                                            I’m not so sure about that, because it’s not just the fetch API you need to worry about. If you look at Bootstrap’s efforts to remove jQuery then they had to do a lot of work and write helpers to ensure cross-browser compatibility. Turns out not everyone is running the latest Chrome.

                                                                                                        1. 5

                                                                                                          The documentation isn’t exactly “very verbose”