At least they were humble and didn’t blame it entirely on Cursor… they also blamed Claude.
Before Git, we used SVN (Subversion), and CVS before that. Microsoft shops used TFS or whatever it’s called now (or was called in the past)
I thought mercurial was older than git, but apparently it’s 12 days younger.
A place I worked at did it by duplicating and modifying a function, then commenting out the existing one. The dev would leave their name and date each time, because they never deleted the old commented out functions of course, history is important.
They’d also copy the source tree around on burnt CDs, so good luck finding out who had the latest copy at any one point (Hint: It was always the lead dev, because they wouldn’t share their code, so “merging to main” involved giving them a copy of your source tree on a burnt disk)
Wasn’t it Visual SourceSafe or something like that?
God, what a revolution it was when subversion came along and we didn’t have to take turns checking out a file to have exclusive write access.
Visual SourceSafe
Yes! That’s the one I was struggling to remember the name of. My previous employer started on Visual SourceSafe in the 90s and migrated to Team Foundation Server (TFS) in the 2000s. There were still remnants of SourceSafe when I worked there (2010 to 2013).
I remember TFS had locks for binary files. There was one time we had to figure out how to remove locks held by an ex-employee - they were doing a big branch merge when they left the company, and left all the files locked. It didn’t automatically drop the locks when their account was deleted.
They had a bunch of VB6 COM components last modified in 1999 that I’m 80% sure are still in prod today. It was still working and Microsoft were still supporting VB6 and Classic ASP, so there wasn’t a big rush to rewrite it.
Welcome to my world… our new lead architect has mandated that we move everything from TFS to GitLab before the end of the year. I hope it comes true.
At the start of COVID, I migrated our three projects to git from VSS. I also wrote a doc for our other teams to do the same. It was amazing once we got it working. Small team of 3, but we started using feature branches which enabled us to easily merge everything into a testing branch and release only certain features at a time. So much cleaner.
Before I left, I almost got semi automatic CI/CD working with Jenkins!
That or when SourceSafe was literally deleting random files because it was full of bugs.
I remember when our company split up and we had to give them the source code of some older versions that they still used. We couldn’t do that because the repo was corrupt meaning that we couldn’t access some older revisions. We had no problems using it day to day so nobody noticed which meant that all backups were also corrupted.
The worst was when someone left for vacation without releasing their file locks.
Vacation is a quaint problem lol, at least you know they’re eventually coming back. What do we do about the guy who retired 5 years ago and still has locked files in his name?
There are ways…
Is it possible to learn this power?
Oh god, thanks for that fucking PTSD bomb
Yeah VSS was the predecessor to TFS, and now TFS is called Azure DevOps… whatever the fuck that means, Microsoft needs to get it together with product naming. Anyway TFS sucks major rotten ass. I have my problems with git - namely user friendliness - but TortoiseGit has put all those troubles to rest.
Nothing like that can fix TFS.
I started at a company that uses ADO (migrating to GitHub this year) and it took me like 20 minutes to figure out how to change repositories in the UI… idk how they built something that unuser friendly
I could go all day with my grievances… For some fucking reason, Team Foundation Server thought it would be a good idea to model their source control on folders and files rather than atomic nodes of changes like git.
I’m sure someone thought this was intuitive, but it falls apart once you realize you can check in cross-branch or even cross-project files into a single changeset. This allows you to easily pollute projects you’re working on but didn’t intend to modify yet, if you forgot to exclude their files. And then, when your code reviewer checks the history of the project folder you modified, they don’t even notice all the files you changed that WEREN’T in that folder but were part of the same changeset. So you pass your review, and all the sudden there’s unwanted, unnoticed, and untested changes in some other project, with a nice code review stamp on them!
And the entire checkout/checkin system is just flipping the read-only flag on the files in file explorer. It’s the most amateurish shit. If you edit a file in an open, active project, the file gets checked out automatically. But if you’re editing loose scripts that aren’t part of a bespoke SLN or CSPROJ, you have to check those out manually… which it will only tell you to do once you try to save the file.
And then Visual Studio cannot understand that I might need to switch regularly between 2 types of version control systems. If you’re not on the same VCS plugin when you want to open a recent project on it, it doesn’t automatically switch it for you, it just refuses to load the project. The only way to reliably to switch is by going into the options menu, changing it there, THEN loading the project.
git is practically made of grease compared to how stuttery and clunky TFS is. I’ll shed no tears for the fossils who are having a hard time learning git, they will be better off whether they realize it or not.
And throughout it all was the tried and true v3.0-final-UPDATED-4
The best is when the version also had the name of an ex employee on it.
if it doesn’t have both _draft and _final in the name and at least one (1) in it, are you even really versioning?
20+ years on and I still have some unresolved Clearcase trauma.
eh heheh we still use clearcae hehe … heh
TFS actually moved its core version control to Git in 2013 and was later was rebranded as Azure DevOps a few years ago
Thank god, we STILL use TFS at work, and its core version control model is reeeeeally fucking awful.
My first SWE job out of college in 2019 they were still using SVN because none of the seniors could be bothered to learn how to use git.
The “well this is how we’ve always done it” attitude had a death grip on that place
SVN is fine for most corporate workflows. Your project is probably not anything like Linux.
For what it’s worth, SVN is a much simpler object model compared to Git, which makes it easier to understand.
It’s centralized rather than distributed like Git is, which has some disadvantages. Most operations require access to the server, as opposed to Git where you usually have a copy of the entire repo and can work offline. Git users can clone the repo from other users rather than relying on a centralized server.
On the other hand, a centralized server also simplifies some things. For example, instead of commit hashes, SVN has revision numbers, which are natural numbers that start at 1 and are incremented for every commit. A lot of software that used SVN used to use the revision number as part of the version or build number.
Git is definitely the source control system to choose today, but SVN can still have its place.
For those reasons, I choose mercurial over git whenever I can.
Oh yeah, I remember using tortoiseCVS briefly.
Mercurial and Bazaar also showed up at around the same time as git, I think all spurred by BitKeeper ending their free licenses for Linux kernel devs.
An interesting shot to the foot, that one.
BitKeeper was a proprietary version control system that somehow (and with a lot of controversy) ended up being adopted by a big chunk of the Linux kernel developers, while others were adamant against it.
In any case, they provided free licenses to Linux devs, with some feature restrictions (including not being able to see full version history) only available for premium clients, while Devs who worked on open source competing systems were even barred from buying a licence.
When someone started to work on a client that allowed access to these locked away features, they revoked the free licenses, and a host of solutions started being developed immediately. Linus Thorvalds himself started work on git, and that eventually got adopted by the whole Linux ecosystem and, nowadays, the world.
As for BitKeeper, it’s been dead for years now.
I remember SVN
I want to forget SVN
I want SVN little explorer icons back! I want to forget Jazz RTC.
That’s tortoise, and have I got news for you: tortoisegit exists.
I never understood the SVN hate. Then, as now, the problems are almost never caused by the tools, and almost always caused by the people misusing them.
I never got around to using anything except git, partly because of all the hate people would throw at the other competitors back in the day. Even if the criticisms were not fair, and even if it was all a secret conspiracy to kill git competitors, it definitely worked out for the best. Imagine the hell we’d be in today if we had to constantly deal with different VCS solutions.
It wasn’t really that big a deal. Most of them have more in common than they have differences. If anything, I experienced fewer problems in the age of SVN. It has fewer options than git, but it’s also a lot more intuitive and easy to learn, which counts for a lot when your largest limiting factor is your coworkers.
Not saying I want the world to go back to that, just pointing out the hate is really overblown.
I run a svn server at work
My condolences
Ahh yes, programming by vibe. The vibe is always dumbass. Just steal code that has already been explained to you like everyone else.
already been explained to you
This step is optional
It’s actually reassuring to see that despite all warnings and doomsayers there will still be opportunities for programmers capable of solving problems using natural intelligence.
If anything it feels like we’re the doomsayers trying to warn people that their AI bullshit won’t ever work and they’re just not listening as they lay off the masses and push insecure and faulty code.
And then years from now when this all comes to a head, they’re gonna hire some poor schmucks to fix that crappy code
Acts like SVN and CVS didn’t exist
Also like Reddit did
this guy would have force pushed onto main about 10 mins after this if he did have git
Tbf you have to do that for the first push, if a Readme file was autogenerated
Does that still happen if you use the merge unrelated histories option? (Been a minute since I last had to use that option in git)
Never have heard of that, but in the case of you also having a Readme that will be even more complicated, I imagine. So just adding -f is the easier option.
You don’t if you just clone the repo you created.
Huh? I’m talking about existing code being in a dir, then initting a git repo there, creating a pendant on your hoster of choice and then pushing it there. Wouldn’t cloning the repo from step 3 to the code from step 1 overwrite the contents there?
There are multiple solutions to this without using --force.
Move the files, clone, unmove the files, commit, push being the most straightforward that I can summon at this time… but I’ve solved this dozens of times and have never use --force.
If your remote is completely empty and has no commits, you can just push normally. If it has an auto-generated “initial commit” (pretty sure Github does something like that), you could force push, or merge your local branch into the remote branch and push normally. I think cloning the repo and copying the contents of your local repo into it is the worst option: you’ll lose all local commits.
You can also just tell GitHub to not do that.
True, in the situation with a local history maybe it’s worthwhile to --force to nuke an empty remote. In that case it is practical to do so. I just typically like to find non-force options.
If it’s a single, generated, “initial” commit that I actually want to keep (say, for ex I used the forge to generate a license file) then I would often rebase on top of it. Quick and doesn’t get rid of anything.
deleted by creator
Yeah, I was thinking of a new repo with no existing code.
In your case you’d want to uncheck the creation of a readme so the hosted repo is empty and can be pushed to without having to overwrite (force) anything.
And then lost the reflog by
rm -rfing the project and cloning it again.God bless DCVS.
You need a USB C “Power Ctrl+Z” key. Unlike the regular Ctrl+Z key one of these bad boys is capable of reversing edits across system reboots until as far back as when you originally plugged it in.
Sounds to me like a glorified keylogger 😭
From what I understand, you could un ironically do this with a file system using BTRFS. You’d maybe need a
udevrule to automate tracking when the “Power Ctrl+Z” gets plugged in.
“Developer”
“my” 4 months of “work”Those are the ones easily replaced by AI. 99% of stuff “they” did was done by AI anyway!
Ah yes, the elusive AI “programmers”.
The vibes were off.
Yeah this what you get when you code based on vibes.
Git wasn’t the first version control software. I remember using sccs back in 1991 and apparently it was written all the way back in 1972 https://en.wikipedia.org/wiki/Source_Code_Control_System
Don’t trust anyone who can’t spell ‘oops’.
Maybe he was cursing the god of dev ops
Nah his opps fucked up his backup.
His operations department?
Just a heads up, it you don’t know how to use cli git in 2025 you’re probably a shit developer. There are undoubtedly exceptions, but I would argue not knowing version control intimately makes you a bad developer.
Why learn an archaic and honestly horrifying command line interface, possibly the worst CLI ever made in the history of computing…when nice normal graphical interfaces work better, have discoverability, have troubleshooting tools, and don’t require memorizing scripture?
Mate… Theres maybe like 5 “git + singleword” commands that cover 99.999% of all of your uses of git. Its really not hard.
The fact that you don’t already know why and are dependent on GUI tools that you don’t fully understand is the reason that you’re probably not a very good developer.
Git is incredibly powerful. Knowing why and how is infinitely valuable. Nothing about git cli is archaic or even particularly difficult to understand. Also the man page is very excellent.
Ah, the no true Scotsman fallacy. Neat.
Your lack of rational thought backed up by facts rather than feelings is why you’re a bad developer.
See I can do it too.
But honestly even saying “nothing about the git cli is archaic” is…well, it’s either disqualifying or Stockholm syndrome, and Stockholm syndrome isn’t real.
I said that you are probably not very good. Your lack of git knowledge and your seeming inability to learn git means that you’ll likely never be able to function effectively in a development team and will only succeed in holding everyone back. Your lack of knowledge of version control overall is a massive point against you from the outset.
If you’re a solo developer and never need to collaborate with other developers then good for you, but you lack of version control knowledge means that you’ll also probably end up being one of the ones crying that you lost 6 months of work because of stupid reason x y or z.
Read up on fallacies, I did not use one. Your pathetic attempt to shoehorn anything that I said into a no true Scotsman fallacy just shows that you also have poor communication skills.
Holy fucking shit. I didn’t even catch the bit at the end. You really think that cli arguments are archaic??? I’m going to go ahead and assume that regex has you scared shitless as well. Fuck me, you are not a good developer.
Sidenote, something that will help you understand regex and you can test your strings against it in realtime, look up https://regexr.com/
Because they are universally incapable of coming anywhere close to the full power of git.
I can’t tell you how many times I’ve had GUI-only people ask me to unfuck their repo (fortunately not at my current job, because everyone uses the CLI and actually knows what they’re doing). It’s an impedance to actually learning the tool.
Ultimately any GUI is a poor, leaky abstraction over git that restricts many of the things you can do for little actual benefit.
Most cli stuff is a lot easier than programming. If you can’t use cli then by definition you’re a shit programmer.
Of course if you simply don’t want to use cli that’s a different matter.
Why learn a GUI that can change from release to release when I can learn a CLI once and be done with it. An additional plus is that CLIs are easier to script and automate.
There’s nothing ‘archaic’ about git’s CLI. I think you might just be opposed to CLI’s in general, which is fine for a regular computer user, but paints a grim picture of your competency if you’re a developer.
That seems unnecessarily harsh.
I find the built in controls with visual studio supremely convenient.
After using git init --bare for the remote repo I use the built in git controls for branching and switching out as well as syncing and pushing. Why not, the button is right there and it’s literally faster.
The difference is that PRESUMABLY you aren’t utterly dependent upon it. If vscode utterly fucks your repo with a shit command, you’ll not really have any trouble fixing it. That’s the huge difference. The point is not that all GUI controls are always bad all of the time, the point is that you need to know what the hell you are doing in git as a basic tenant of developer competency.
As someone using git for the last 10 years by now: you’re wrong. No UI has managed to give me access to all the fuckery I often do very quickly on the command line. I was honestly surprised to see IntelliJ nowadays supports an interactive rebase, but reflog, which should be a basic git feature, is still not widely supported in most IDEs in 2025. Or adding, resetting or checking out files with regex. Setting up and modifying lfs. And these are all basic features, good luck doing something like using branch~n syntax for some of the operations etc.
Git UI is shit and will be for a long time.
subversion. those were the days…
Was my first experience with source control, a bunch of Gary’s Mod mods were distributed that way, think I recall wiretool doing that, spacebuild was for sure, predated my work use by like 5ish years.
I didn’t hate it but definitely prefer git, but I’ll take literally anything over not having it,
Haha I literally thought of this exactly, Garry’s Mod. Why do I need this tortoise crap, just gimme a zip. Ah, summer child.
We still use it in my job.
Pls help.
svn was invented in 2000
CVS was invented in 1986
SCCS is from 1972, you young whippersnappers
SUN is from 4.6 billion years ago, you mortal beings
I’m a software developer so I’ve never seen that thing you’re talking about, but check your sources, I believe it’s actually from 1982: https://en.wikipedia.org/wiki/Sun_Microsystems
I landed in the middle. SCCS was too old, CVS was too new.
https://www.gnu.org/software/rcs/
But, back then, I had also been forced to use CMVC.
https://en.m.wikipedia.org/wiki/IBM_Configuration_Management_Version_Control
When
bzr, and thengit, turned up and I started using them, I was told “this is DVC, which is a whole new model that takes getting used to”, so I was surprised it seemed normal and straightforward to me.Then I found out that Sun’s Teamware, that I had been using for many years, was a DVC, hence it wasn’t some new model. I’d had a few intervening years on other abominable systems and it was a relief to get back to DVC.
Regarding the original post, are there really people around now who think that before
gitthere was no version control? I’ve never worked without using version control, and I started in the 80s.
Now Target owns them, I think.
