skysight-inc/HackerNews huggingface dataset:
If these apps effectively become mandatory for restaurants owners and start to squeeze them then it's a problem.

But regarding drivers I feel that we're confusing causes and consequences: If being a delivery drivers for these guys is so bad then why do they seem to still find so many people willing to do it? So it seems to me that these apps are not destroying anything there. The destruction happened before and these apps are picking up the pieces and providing jobs.

Also, it's not like being an old-style delivery driver for a pizza joint was ever a very good job...
Is it git that's too hard, or is it that version control is too hard? I suspect that it's the latter.

That is, version control is difficult and git is a powerful tool that exposes that difficulty and the many (complex) ways to approach version control.
I am not sure that is true at all.

It’s way more important to understand that git has 0 consistency of what the command name is and what object it manipulates.

Git checkout can create both branches and files. Why? Wouldn’t it be easier to have two commands for checking out a file from a different branch and creating a new branch?
> the delivery apps like DoorDash and Uber Eats just work a lot better than calling up restaurants for delivery did in the pre-app era.

Not my experience for takeout.

Before: I called in an order, they told me how long it would take, I would arrive, it would be done.

After: I submit an order via the app. I receive confirmation and an estimated time. Arriving at the time is optimistic, so I arrive 5 minutes later. I find staff juggling half a dozen (often more) devices, one per app, and converting them to whatever their internal order system is. Frequently they have entirely missed my order and who can blame them because they've gone from phone & counter "inboxes" to more than you can count on one hand. You can ask staff which app tends to be most reliable and they'll tell you which one they pay the most attention to and that has a hope of reaching parity with phone orders.

Delivery's a little different of a beast, apps have made the market for that kind of service more "liquid" and responsive, but it remains to be seen exactly what the models look like without growth capital subsidies.

> But like music, it won't just go away, it'll be a new business structure that perhaps dominates the industry.

If this is the comparison, then be afraid, because streaming has both destroyed a huge amount of value in recordings and redirected a significant portion of remaining value towards new middlemen.
There has been, and they never really get anywhere (Ex: OrderAhead). They all seem to end up at the doordash / uber eats / yelp style locus point and there might a reason we are seeing the same pattern shake out globally.
GeForce+NOW+on+Chromebook:+Bring+Your+Games+with+You –+Nvidia+Blog
Apple Silicon M1 MacBook Pro Earns 7508 Multi-Core Score in Cinebench Benchmark
DKIM's protection aren't as strong as people say they are (though fairly strong)

1) DKIM doesn't protect the To: header in any reasonable way (its not really designed to). i.e. it protects it in the sense that the original email had that as the To: header, but this is easy to forge as the To: header is not used by SMTP in delivery (think Bcc). i.e. its easy to write emails that are To: <some address> that are never attempted to be delivered to said address.

2) DKIM (even on gmail) doesn't quite protect the From: header as one would expect. Yes, gmail in general makes it difficult to spoof the email in the From header (it will replace it with your own if you try in the general case), but there's a huge but, if you gave gmail itself access to use that e-mail. i.e. I can be compsciphd@gmail.com but if billgates@gmail.com was convinced to allow me access to send emails as billgates@gmail.com (either via cooperation or a technical or sociological hack) then i can do that without having access to the account. and this permission is permanent. as far as I can tell, it irrevocable and to other gmail users there is no indication that other accounts have this permission for your email.

so what do we learn

1) can't 100% trust DKIM to believe who an email was sent to unless you actually retrieved it out of said user's email spool
2) can't 100% trust DKIM to believe who actually sent an email (even on gmail)

now, do I think DKIM gives anywhere close to 0% trust. No, I think its much closer to 100 than 0, but one has to understand the limitations and most people who discuss it, don't seem to understand them.

the threat is a hack playing a very long game. If one doesn't view that long game hack threat as serious, then its close enough to 100% (especially if gmail rotates their keys even without making the private part public), but if a long game hack threat is a serious thing, then it drops.
Exactly. Reading a book about git will not help you understand why commands are named so weirdly.
I'm not an idiot, but I don't fully understand git. I am coding for a living, and I use git every day. I probably could sit down for a couple of days and fully understand how git works, but I've never needed it, I understand how basic git operations work, and I stay away from commands that I don't understand. With GitHub desktop you don't need to open the command line for any standard operations, I only need to use the terminal for cherry picking.

The reason I want to stick to the basics is because of one interesting thing I've noticed: a lot of engineers sincerely believe that they are git experts when they are nowhere close. And until I locked down the GitHub repo with admin privileges, that was a dangerous thing. So I'm trying to work a system where no one in a team where not everyone is truly expert at git only uses the basic commandset from git.

One thing I can say again to emphasize - git maybe the simplest Vcs you've used, but it's not a simple tool, and its most definitely not intuitive for everyone. If it is for you, that's great, but maybe there's a lesson here about how not everyone's brains are wired the same.
I remember they had some issues at the beginning of a year when international lockdown struck. That huge surge of remote workers made problems for many companies.

But I’m using them for few years and never been happier. :)
Git is hard because it precisely models the complexities of concurrently modifying source code on multiple computers. It explicitly models all of the concepts and operations that are relevant in that domain - branching, merging, my local changes, the server that my local branch is kept in sync with, rewriting local history, rewriting public history. Can you shoot yourself in the foot? Absolutely, because this stuff really is non-trivial. Could it be made easier? Yes, by limiting what operations you're even allowed to make, and streamlining those (c.f. git flow).
Honestly I don't think that is git's fault
You complain about a blog post right here right now. Time to switch to trucking?
It’s also sneaky how they get to pin their apps but other developers don’t.
The article's point isn't that there's no reason to delete a remote branch, but that the concept of them is a conceptual leap that one doesn't naturally make until confronted with certain situations.

Otherwise I agree with you; with my team I documented the standard feature/bugfix development process including the git steps, last of which is the lead engineer merging the branch and deleting it on the remote.
> I'm not trying to threaten or scare you

It's ok, I did do this; like said above, the source (and all keys/access) are in escrow at a notary for the projects I run in case of bus-hitting. Also, I am not working alone, but yes, I will rethink this again as it was a while ago that this was arranged.
The commands suffer from backwards compatibility. And at some point in git's development it was easier to get new options to existing commands approved than new commands. So that's eg the reason 'checkout' and 'reset' do lots of different things.

I wonder whether we could create a much better and more consistent command line interface from scratch?
If you're more about learning by trying things out, I enjoyed these two:

https://learngitbranching.js.org/ (which presents a visualisation of the commit history)

https://github.com/Gazler/githug (nice for small exercises; although you kinda have to pay attention and not just 'game' your way through it).
My grandfather's Windows 10 is constantly switching his default browser to Edge after updates. The poor bastard is very aware and anxious of his own cognitive decline, so when his computer starts behaving differently for no reason, he thinks he is to blame. Microsoft is literally making my grandfather doubt his mental capacity. I realise they're not doing this deliberately, but when companies behave unethically, it has unexpected consequences.

It's a similar story with his Antivirus software, which is constantly trying to convince him he needs to upgrade his subscription with useless browser extensions and other unnecessary features.

Windows is a fucking minefield for old people man.

And don't even get me started on how insanely impossible internet banking is for old people. His bank's idea of two factor authentication is to send him a TXT with a code, which he has to reply to with said code, as well as another code on his computer screen. He's got a flip phone for crying out loud! You know, one of those phones where you have to keep tapping 1 to get an A? His bank has literally made internet banking impossible for him. What's he supposed to do, get a taxi to the bank every time he needs to pay a bill? I realise protecting old people from bank fraud is extremely important, but did they ever test this crap with old people to see if it's workable??
“How do I branch in Mercurial?” seems to have four long answers, and maybe a patch queue makes five?

https://stevelosh.com/blog/2009/08/a-guide-to-branching-in-m...
Drawing lots of faces with sketch-RNN
Earlier this year, I wrote a blog titled 'A simple Git workflow' https://www.iwriteiam.nl/D2009.html#30 and now that I am rereading it, it does not feel simple at all for a first time user. And note, this simple workflow does not even use branches. It was only recently that I found the two global settings that makes lives for first time users so much easier. Why not make them default?
As an American who now lives in Germany, it does make me think how the U.S works at all without this "registration". There are times where you fill out government forms with your address, but there's no way to know for sure where someone is living at any given moment. As far as the "government" is concerned (which government? state, local, federal? AFAIK it's all pretty decentralised) I'm still living at the place I registered to vote from years ago.

I suppose it's cultural differences. There's a staunchly individualistic attitude in the US and the idea of a central government tracking its citizens is very unpopular. I get it, too. If you take a look at the "Anmeldung" process in Germany, where the government has a list of everyone and their race/religion/nationality, along with exactly where they live/which building/which floor/which side of the building, you can see how such a system could be dangerous if Germany were to ever shift from the liberal democracy it is today.
> First, I don't get why diversity is given passing mention when there's nothing related specific to diversity or gender politics in the solid idea discussed by the article.

It links to the paper describing how non-promotable work is divided between genders in a mixed setting. This is clearly a diversity problem. If women take the bulk of work that won't get them promoted, you end up with women underrepresented in senior positions. Did you read the article?
Use command line. Try creating playground repo and play with it. You can use github's private repos. Use separate accounts to emulate merge conflicts. Start with only those options you feel need: such as tags and so. Read about work models (git flow, and others). Try them in your playground repo.

Basically it's impossible to learn something without trying and making mistakes, and analysing what went wrong. No failing - no success. You will get it, not that hard. Good luck!
Do they even have to be exotic applications? I don't use Chrome very often but I think it is installed. That means I have a very current FF but some specific old version of Chrome. Ditto for a bunch of stuff installed by Macports, that all just updates at once but pretty infrequently. I don't recall the last time I updated Steam. Seems easy to fingerprint someone with just a handful of even normal apps.
I loved using Mercurial. It provides such a nice UX and it is very intuitive to use.

It's a shame that github was created and not MercurialHub and now we are stuck with Git.

Now even Atlassian abandoned Mercurial.
> "if it's in the AGB (terms of service) good luck arguing/defending"

It might be hard to argue without suing, but legally there are provisions that if the AGB contain “surprising” terms, you have to be made specifically aware of them or they are invalid. There is currently a high-stakes case building because of this: Some of the epidemics insurances for restaurants had a provision that “pandemics” are excluded and won’t pay out for COVID-19, now restaurants are suing.

https://www.srf.ch/news/schweiz/epidemie-versicherer-kein-ge...
The syntax is also a bit inconsistent, and reflects git's own development history.

We could probably make a new and better command line interface that brings out the underlying simplicity more.
Speculation. The FP community prizes mathematical beauty, for which symmetry is an important factor. It is simply ugly to promote one function argument (which one?) to a privileged role, even if the linguistic side of the brain screams that's the right thing to do.

Re autocomplete, there is no technical reason why auto-complete couldn't trim down the search space based on the arguments of the functions, for example by using reverse polish. But reverse polish is unusual, we really like SVO anyways, and modules as subjects are very useful, if only as an autocomplete anchor, in tooling or in one's brain. OOP/SVO is here to stay for the foreseeable future, and embracing pure functions principle makes it rather pleasant to work with. If only we could decouple 'modules as namespaces' useful idea from all the misguided baggage that comes bundled with OOP, of which the 'active data' antipattern deserves special 'please avoid' mention.
> OS updates spontaneously reset your default browser back to Edge

I've never seen this happen, and I have Chrome as default. I noticed the other issues you point out, but this never happened to me the years I've been dual-booting with Windows 10.
The article title is misleading as only the Burbank Unified School District banned books
Imho Mercurial is much easier than Git. I have seen team members who lost data with Git but never with Mercurial.

I still miss Mercurial. Unfortunately most people moved to Git so I also moved to it.
I disagree. Git definitely has a learning curve just like all tools do. But as an engineer, you should learn it accordingly.

And honestly, once you understand the concepts of git, you don't need to remember the commands, you need to search for it. Just like you search for all sorts of problems in whatever language you're writing in.
If anyone is looking for a git GUI, Fork is great https://git-fork.com/
Based on the talk [0] where the OP suggested it number of times. She mentions the engineer being rusty and having significantly fewer code contributions than her peers.

In general, if the glue person has intermediate knowledge of the codebase, they'd get promoted without much controversy. In such a case, it should not be difficult for them to bang out a couple of features and ship it, for example.

[0] https://www.youtube.com/watch?v=KClAPipnKqw
There are numerous git <-> svn cheat sheets ... this is literally one of the first things I learned. I’m kind of bewildered by this to be honest ... I don’t know how somebody with a technical qualification could have trouble with this ...
Time most certainly is not a dimension (or even very dimension-like, in general) in my opinion. It structures the orderings of events, more like some ultimate process that all other processes are hanging off (are a part of). The complexity in the ordering could be irreducible at any given point, depending what is happening there, and that includes fully non-reversible processes. To me, this is time's arrow.
Data Type Algebra: Sum, Product and Calculus of Mutation [2009]
Vietnam has the most features, but no ability to engineer them to match Chinese capabilities. The islands themselves are marginal, good for small landing strip and some basic installations, most need an inordinate amount of work and investment to become useful. Vietnam is simply incapable of producing a dredging company as large as Chinese CCCC, a byproduct of serving a country with 1.4B people. I think Mischief Reef alone reclaimed 1400 acres, about 10x than all Vietnamese dredging efforts. It's a massive undertaking but relative to goals. Vietnam's goal is just to claim stakes, which they can do with something as rudimentary as brick buildings, a dirt landing strip for supplies and DK1 rigs. Also see Philippines' Sierra Madre on Thomas Shoal, literally a beached ship to base a handful marines out of. China's goal is to push back USN, which requires a legit base, full runway for modern fighters, reinforced hangars and all associated support infrastructure. There's also work on geoengineering fresh water and agriculture to strengthen claims - turn feature into proper island for EEZ rights. If properly weaponized, it could make every USN asset in SCS vulnerable. During a shooting war, it would get wiped, but there's enough hardened infrastructure that US would expend substantial munitions. It's just another scale of construction and capabilities.
Agreed - I started to use version control back with SCCS somewhen in the early nineties, and RCS, CVS, Subversion, ClearCase, some Microsoft horror with a name I can't recall, and a few others. My conclusion is exactly the same as yours: "Git is the simplest version control system I've ever used." And it also improved my overview over what happens and has happened in the past - I can jump back in for stuff I haven't touched for many years. So I now think of the older version control systems I used over the years as simple "snapshot backup" systems, not real version control.
(NB: I've never actively used Mercurial, other than because some projects use it, so I'm not comparing Git and Mercurial, or the other one or two systems with similarities.)
> I don't want my private communication to become public, or publicly verifiable. That doesn't mean I'm not "innocent". This is not a fringe concept: https://en.wikipedia.org/wiki/Nothing_to_hide_argument

Yes, I agree we should have secure private messengers. But that has nothing to do with this discussion. First off, email is not a secure private messenger. Second, email would not become "more secure" by removing the accidental, partial non-repudiation that DKIM provides. Third, this comment chain that you are replying in right now, is about whether there exists any legitimate need for a third party to authenticate emails with DKIM after the emails have been sent. tptacek claimed that no such legitimate need exists. I've been arguing against this with a specific counter-example.
Independent artists call new Spotify scheme “Payola”
First of all, I'm sure the author knows more about git than I do, so I don't wanna come across as trying to lecture an expert. But I do feel that his main point misses the mark. It seems to be centered around the idea that a lot of reasonable people are surprised by things git won't let them do (or, more accurately, strongly advices against doing). The problem is that most of these things are only "reasonable" from the point of view of someone who hasn't thoroughly thought through what a DVCS has to do. A lot of the "reasonable" questions are raised from the point of view of "this is a tool for sharing changes to code". But that is just a nice side-effect of what a DVCS aims to do – it is not the goal.

I too have had to clean up git mistakes of collaborators for years, almost all of them rooted in a misunderstanding of what git does, or carelessness (amplified by git's arguably less-than-stellar naming conventions). But is there really any chance that any DVCS will be "easy" (or "not too hard") for someone who hasn't thought about and internalized what the goal of a DVCS is? It seems a bit like a person who only ever spreads butter complaining that knives are needlessly sharp.

PS: My greatest success rate at converting people from "just hammer git commands until my code is on GitHub" to actually understanding what problem git tries to solve, and how to interact with it, has been from Mary Cook's wonderful Git from the inside out (https://codewords.recurse.com/issues/two/git-from-the-inside...)
There is a relatively easy way to accomplish this by editing your .git/config file to point at the new "authoritative" repo.

But there is a simpler (although less efficient) method. Just simply git clone the new repository onto any machine you want. The clones will naturally be configured to point to that new repository as their upstream.
Anyone that intends to run OpenGL applications in Win32 sandbox, UWP sandbox or just use store apps.

The OpenGL 1.1 ICD driver model that OEMs take advantage of to deliver more modern drivers isn't supported in those scenarios, and most likely is going away with either Windows 10X or some future version of it.

https://devblogs.microsoft.com/directx/in-the-works-opencl-a...

Microsoft also had a version of this back when Windows 8 got released,

https://github.com/microsoft/angle
I've read this as a rant about why we should want a fancier SVN. Unsurprising coming from someone working at Github, but hardly representative of what git was made for and can actually do.

Centralisation is easier, but generally the wrong solution. Git is distributed by design, and most of the difficulties come from that. Github makes git easier by making it centralised, and that makes it easier to use, but actually make it bad in some other ways : the the recent youtube-dl debacle.
hg branch my_feature

Simple.
I've used a lot of different version control systems over my many years in the industry and git definitely isn't easy. The basics aren't hard but it's easy to get into a pickle if you need to delve slightly out of common patterns.

The git CLI tool isn't great either -- that's probably the hardest part of git.
> Git is one of those technologies where it's super important to get a good grasp of how to internals work.

If you don't have time for a full book, I think Mary Cook's Git from the inside out is a wonderful start: https://codewords.recurse.com/issues/two/git-from-the-inside...
There is GIT (the system itself) and there is the CLI.
While GIT itself is very elegant and clean, the CLI is the exact opposite. In my experience people who struggle with GIT mostly struggle with its CLI and do a lot better with a graphical interface, given they understand the concept of distributed VCS.
> I soon got the impression that QBasic community has usually been another case of the blind leading the blind.

I have a feeling this was especially the case in the 90s, but there have been some great people sharing high-quality works in the early 2000s QBasic scene.
Where have I offered any explanation for anything?
> And apple sneaking in applications on windows when updating quicktime (if I remember correctly).

OHHH Quicktime! Every time I put iTunes on my windows computer and auto-update would install Quicktime.

Thanks for reminding me of those dark days.
Sign a PDF Online
The version control system your subconscious mind recoils in horror from is the dreaded Visual SourceSafe, one of the worst-named product ever.