It seems Meta is able to set some rules about the interoperability making it very difficult for an FOSS implementation to emerge. Additionally organizations like Signal though technically interested in this interoperability have stated they won't lower their security standards for this.
Since recently Meta offers this as per European Union mandate (Digital Markets Act, DMA). For both Whatsapp and Facebook messaging. [0]
Now there are a lot of implementation requirements, basically forcing you to have some kind of messaging provider. Therefore difficult to apply for an open source solution. However there is such an interface.
Location data should be opt in on capture, a checkbox deep in the settings: "capture location meta data" would be sufficient, or a button similar to the flash.
Strange UI that they are involuntarily capturing but then removing it.
Well around the time of the first typewriters (late 19th century) there where mechanical typesetters, automating the laborious task of typesetting for the printing press. Of course the mechanics of printing where different but as far as I know this is the source of the "keyboard with buttons" type interface for producing literature.
> The old model assumed one person, one branch, one terminal, one linear flow. Not only has the problem not been solved well for that old model, it’s now only been compounded with our new AI tools.
A bit of a strange thing to say in my book. Git isn't SVN and I think these problems are already solved with git. I agree that the interface is not always very intuitive but Git has the infrastructure which is very much focused on supporting alternatives to "one person, one branch, one terminal, one linear flow".
> the problem that Git has solved for the last 20 years is overdue for a redesign.
To me it's not clear what the problem is that would require a redesign.
>Git was built because the commercial license of BitKeeper became unworkable for the Linux kernel community.
BitKeeper was free to linux kernel developers with a "but no reverse engineering" clause, but Tridgell went exploring of his own volition because he wanted to and kinda sorta violated that, so the license was cancelled by BitKeeper.
I'm not taking sides or upset about any part of this, I just wouldn't call that "becoming unworkable for the linux kernel community"; that would be like "the fence around your yard became unworkable for me in my desire to trespass on your property so I climbed over it"
what Tridgell discovered was pretty dumb and could be considered a distinct lack of a fence, but he connected to a socket and typed "help" and it dutifully printed out a bunch of undocumented useful commands.
Yep, something that is sadly becoming more and more common. People with solutions spending insane money trying to convince others that a problem exists.
Skill issue. It's the most popular VCS in the world by a huge margin, millions of devs use it every day just fine, countless forges have been built around it, and there's only one semi-compelling alternative frontend (jj). If you honestly find Git challenging, how are you coping with software engineering? Git is the easy part.
Millions of dev use it in the most rudimentary way, occasionally lose their stash, rm their local repo and start over, ask the office expert for help every time they need to figure out where-the-foxtrot that commit came from, don't even attempt to use reflog or bisect or interactive staging, etc.
> To me it's not clear what the problem is that would require a redesign.
The interface is still bad. Teaching people to use git is still obnoxious because it's arcane. It's like 1e AD&D. It does everything it might need to, but it feels like every aspect of it is bespoke.
It's also relatively difficult to make certain corrections. Did you ever accidentally commit something that contains a secret that can't be in the repository? Well, you might want to throw that entire repository away and restore it from a backup before the offending commit because it's so difficult to fix and guarantee that it's not hiding in there somewhere and while also not breaking something else.
It's also taken over 10 years to address the SHA-1 limitation, and it's still not complete. It's a little astonishing that it was written so focused on SHA-1 never being a problem that it's taken this long to keep the same basic design and just allow a different hashing algorithm.
> Well, you might want to throw that entire repository away and restore it from a backup before the offending commit because it's so difficult to fix and guarantee that it's not hiding in there somewhere and while also not breaking something else.
Perhaps proving the point here. That's not enough to eliminate the secret, the dangling commit will persist. Though this might be a nitpick, it's rather hard to get it from the remote without knowing the SHA.
> generate a new key
Is absolutely the right answer. If you pushed a key, you should treat it as already compromised and rotate it.
Of course is not true - look into git filter branch. I had to use it once when a developer checked in a whole bunch of binaries and created a PR which ended being merged. I had to rewrite the history and delete the files from history - just deleting the files would not suffice because the file were in git history and we’re taking too m&ch space.
The interface can be independent of the implementation. Under the hood git does everything you need. If learning to use it at a low level isnt appealing, then you can put an interface on top which is more ergonomic.
Git still doesn't work well with non-text data, including being incredibly slow. There's a reason why game studios use things like Plastic SCM and Perforce.
There may be situations where the git defaults aren't ideal.
I found that for the special scenario of game development git-lfs did the job quite well for me.
> Git still doesn't work well with non-text data
Seems like you are either mishandling git in your situation or you require another tool (different merge driver or difftool?). But I would argue that in either case git infrastructure is not "Buggy" as you suggest neither does it need a rewrite like the original article suggests.
It works as intended and additionally it provides you with the hooks and possibilities to adapt it to your workflow, for example handling large binary format files.
Perhaps for your usecase you would be better off using an alternative for example: one drive business, Plastic SCM, Perforce, google drive or an internal file server. That doesn't mean that git should be rewritten to fit your needs.
It feels like you want a regular sedan to both race in F1 and carry the same load as a lorry, use a specialized tool for your needs.
I mean, this can go both ways. "Git solves the problems I care about and any problem outside of that is a misuse of Git" versus what I'm stating.
> Seems like you are either mishandling git in your situation
It's not my fault that Git has become the standard for source control even though not all source is text-based. All the tools integrated with Git, like GitHub, diffing, merging, etc. are based upon text being the norm.
> There may be situations where the git defaults aren't ideal.
Citation needed on this one. Every problem I've ever seen arise with git came from someone not understanding the model or not knowing all the commands. Those don't make it better, but they don't mean it's buggy either.
This is not the problem they are redesigning for, they are redesigning the infrastructure. Github is a live example of a different interface on top of git and that is working fine (though some may have their complaints with it), no redesign of git's underlying "infrastructure" needed.
> Did you ever accidentally commit something that contains a secret that can't be in the repository?
This is an inconvenience for secrets (have become more commonplace since the creation of git) but by my understanding this was a very deliberate choice in the design of git. It grantees integrity in the distributed source. For example you can check the hash of the last commit en be sure that your mirror did not inject malicious code.
> Did you ever accidentally commit something that contains a secret that can't be in the repository?
What do I need to do on top of a git force push, and some well documented remote reflog/gc cleanup, which I can’t find with a single search/LLM request? Are we there, where we don’t have enough developers who can do this without feeling it as a burden? Or are we there where this level of basic logic is not needed to implement anything production ready?
> What do I need to do on top of a git force push, and some well documented remote reflog/gc cleanup, which I can’t find with a single search/LLM request?
This is a self-defeating argument. You're essentially saying we shouldn't improve something because it can be done with a handful of commands (you already know btw) and prompting an LLM.
> Are we there, where we don’t have enough developers who can do this without feeling it as a burden?
The no true scotman.
> Or are we there where this level of basic logic is not needed to implement anything production ready?
Not sure how this fits in with the rest honestly.
It was never about whether it was possible. It was about how it's being done. Juniors (and even seniors) accidentally check in secrets. Arguing that there shouldn't be a simpler way to remove an enormous security flaw feels a bit disingenuous.
If you want to create (or use) another git client that makes removing a secret easy for you and your team you are free to do so.
> It was never about whether it was possible. It was about how it's being done.
That's what I was saying originally, no need to change the infrastructure but you can change how you interact with it.
> Arguing that there shouldn't be a simpler way to remove an enormous security flaw feels a bit disingenuous.
First of all, skill issue educate your employees. Secondly, this is a well considered and a huge part of why git is preferred over older systems like SVN or SCCS especially in an open source context where you are distributing your code through unknown channels and where the publisher might have moved on.
Perhaps Git is not the best VCS for your situation. But I think that if you try other options you will run into bigger problems, there is a reason git became the standard in the industry.
> First of all, skill issue educate your employees. Secondly, this is a well considered and a huge part of why git is preferred over older systems like SVN or SCCS especially in an open source context where you are distributing your code through unknown channels and where the publisher might have moved on.
If you're entire argument rests on people being perfect, it's a trash argument.
Implying that accidents don't happen when you have skills is absurd.
No, I’m saying that you can do this without replacing git. You can make it simpler even without replacing git. Aka you just did a strawman, if you are really into these. Also you answered to me in an authoritative way, when even according to you, you don’t understand my comment. You can figure out a logical fallacy name for this. And also of course a nice fallacy fallacy.
Btw, I’m also saying that who cannot find how it can be solved right now with git, those shouldn’t be allowed anywhere near a repo with write permission, no matter whether you use git or not. At least until now, this level of minimal logical skill was a requirement to be able to code. And btw regardless the tool, the flow will be the exact same: ask a search engine or ml model, and run those. The flow is like this for decades at this point. So those minimal logical skills will be needed anyway.
The problem mainly is that when they don’t even know that they shouldn’t push secrets. You won’t be able to help this either any tooling. At least not on git level.
> Also you answered to me in an authoritative way, when even according to you, you don’t understand my comment.
No, I didn't understand what referring to production-ready code has anything to do with making mistakes in source control.
> And also of course a nice fallacy fallacy.
You keep using words you don't understand.
> The problem mainly is that when they don’t even know that they shouldn’t push secrets. You won’t be able to help this either any tooling. At least not on git level.
You're not actually suggesting you become immune to making mistake after a certain level of experience, are you? That would be insane.
There was a long time when somebody answered me with far right tactics. In this space, they are rarer, for obvious proven reasons. And before you would come, that you are not far right, I didn’t say that, and you cannot prove or disprove it anyway. Even on HN, the Overton window is moved towards far right, as almost everywhere, so value of self claim is not larger than zero, and since large part of society intentionally uses it to make muddy waters, it’s value on the internet is even negative.
> That's not what a strawman is.
Let’s see Wikipedia.
> A straw man fallacy (sometimes written as strawman) is the informal fallacy of refuting an argument different from the one actually under discussion, while not recognizing or acknowledging the distinction.
Let’s see the relevant part of your comment:
> You're essentially saying we shouldn't improve something because it can be done with a handful of commands
Once again
> an argument different from the one actually under discussion
And once more
> You're essentially saying
So the exact thing for which I used, because I didn’t say that essentially. But luckily for us, you just proved that you intentionally misrepresented my comment, and you intentionally argued against something which is not there. Btw, for which you just proved again that you use fallacy fallacy, and intentionally.
I yet to see a case when somebody says, “you’re essentially saying”, and it’s not strawman.
Let’s move on…
> you don’t understand my comment
And immediately after that, you said that:
> I didn't understand
I know, that from your viewpoint this can be difficult, but maybe, you don’t understand something, because you don’t understand something. Maybe you didn’t understand a single sentence from my original comment, and that’s why you don’t understand even the connections between them. Maybe you didn’t understand the general meaning of my comment, and thus you picked something which your mind cannot comprehend, why it’s there, because you didn’t understand even the basics. You “essentially said” that you didn’t understand my comment in general, by doing a strawman with “essentially saying”, but as you proved it was intentional, so I have no idea about your real thoughts.
It’s possible that the general meaning of my comment is fine, but there is an error in the specifics. Maybe, even the general meaning is problematic. One for sure, we will never know, because you still haven’t asked anything, thus revealing that you don’t even want to know. You proved again btw, that it’s intentional, because you still haven’t attacked its general meaning.
> You're not actually suggesting
As we could see from the definition, this is a strawman. And your first question, so here is the answer: no, and my comment is completely rational regardless of the answer. In other words, if the answer would be yes, my comment rationality wouldn’t have changed even a bit. And since, it’s obvious that the answer is no for everybody, and it’s orthogonal to my comment, thus this is a strawman. The point obviously wasn’t to get an answer.
There are two options at this point:
- your arguments are not in good faith
- you do this because you lack skills and/or knowledge
In both cases, any further discussion is pointless.
If it’s the later one, I recommend to learn more, before you ever feel the urge to use any fallacy’s name again. You’re not there yet, but I’m glad that you are interested in avoiding them. A better way of thinking isn’t to avoid specific logical fallacies, but all of them even those which don’t have names. Also using their names won’t ever lead to real discussions in any environments. They can be effectively used only to avoid them for people who cannot think without logical problems as a principle.
If the former, which you proved almost once per sentence, then I hope we will return to positive sum game once, which corrects this behavior with acceptable tools, and you’ll learn from them. Until then, you will continuously make the same mistakes unfortunately, regardless of what I say. I could have proved my points with Lean, and you would still not change a single bit.
I've always wanted a kind of broader and more integrated approach that isn't just about text diffs. the ability to link in substantial comments that would be displayed optionally and not piss off linear readers. links to design and reference documents. bugs and prs that were persistent and linked to the versioned code instead of being ephemeral.
think about all of the discussion we have around the code that gets lost. we certainly have the ability to keep and link all that stuff now. we don't really need to have arguments about squashing or not, we can just keep the fine grained commits if you really want to dig into them and maybe ask that people write a comprehensive summary of the changes in a patch set -in addition-.
but I guess none of that has anythig to do with AI
> macOS machine (which is BSD-like enough down below)
That's like saying an Ubuntu .deb will work on Gentoo because it's all Linux anyway. It's not that simple. There is dependencies and there are differences in the packages, package managers and surrounding system for a reason. It's not 1:1.
Perhaps the naming scheme happened to line up for the packages you where using, but this should be considered not assumed.
It would be nice if there was some sort of translator that could handle "most common cases". I think it would improve the usability of Jails.
Perhaps that would require someone to keep a list of packages mapping certain packages between operating systems.
Something like "apt install python3-serial" -> "pkg install py311-pyserial" may suffice.
For anyone that would use something like that, you should implement a prototype, publish it and perhaps someone else will build upon what you started!
Maybe it's just me but what happened to "don't send your government id to anyone". I am from the EU but this is what was indoctrinated to me. Just seems very strange to all off a sudden send all this information to any company you require a service from.
Also the person is not the company, why is Google making the developer identify oneself while many apps are released under a company? My understanding is that Google has been mishandling this for a while but with the verification linked to a government id that just seems like another can of worms.
A few scenarios to consider:
- The developer is fired/resigns and the company does not want to be associated with the developer, for example if the developer is convicted for something.
- The developer is fired/resigns and the developer does not want to be associated with the company, developer found out about certain practices of the company they don't condone.
- The developer and the company part in good faith, however one of them is being exploited/pressured by a third party to abuse the relationship to the app.
- The developer or the company is on legal hold due to legal issues, arrests, malpractice etc.
- The developer passes away or the company ceases to exist.
- How does this work if you are making an app as a developer for hire, when entering into a contract with a publisher for example. Who will verify and how will that work (especially on small scale apps).
wouldn't the "ancient regex" be the ed "g/re/p" version?
-E, --extended-regexp
Interpret PATTERNS as extended regular expressions (EREs, see below).
-G, --basic-regexp
Interpret PATTERNS as basic regular expressions (BREs, see below). This is the default.
-P, --perl-regexp
Interpret I<PATTERNS> as Perl-compatible regular expressions (PCREs). This option is experimental when combined with the -z (--null-data) option, and grep -P may warn of unimplemented features.
From the manpage it seems my grep make distinction between "Extended" "Basic" and "Perl" regexes.
It seems Meta is able to set some rules about the interoperability making it very difficult for an FOSS implementation to emerge. Additionally organizations like Signal though technically interested in this interoperability have stated they won't lower their security standards for this.
reply