Hacker News Reader

Comment by DamonHD | Hacker News Reader

I still have a few SCCS directories hanging around, back from the 90s-ish I think. RCS and CVS haven't left any trace in my system (they were work only, as was SourceSafe). And my live projects are SVN and git...

Yep, here's the first delta in one of the SCCS dirs...

    ^As 00031/00000/00000
    ^Ad D 1.1 98/04/27 21:02:41 dhd 1 0
    ^Ac date and time created 98/04/27 21:02:41 by dhd

That's from the file served then and now as:

http://www.exnet.com/About_Us.html

And I have found some there from 1995, which is about when we will have taken the HTTP server live...

View on HN

Author of the blog post here!

I am super curious about your experience with SCCS! I have never really used it for personal projects, so the blog post is purely based on research and a bit of trying. Really curious what oyu loved and what annoyed you about SCCS!

We used SCCS on a satellite constellation demonstration system. Two developers shared archives via an NFS mounted shared file system. SCCS was a “check out” model, in that if you wanted to make a change, you first acquired a lock, made your edits, then checked it in releasing the lock.

Collections of revisions were self managed as you say.

RCS came along and I think that’s where the $Id$ construct came in. This would expand to the version number of that particular file - if you const char * const idstr = “$Id$” then you could “strings” your binary and see what components were there. Of course, fileguard #ifdef’s would affect this.

Finally, CVS (maybe) had the idea of tagging, which would associate a single label across a current snapshot of different files and their versions.

In 1993-94, ClearCase came on the scene and tried monetizing this concept. A site license cost $30k in 1994 dollars and required a kernel patch for it to work. Try explaining that to your DEC, HP or Sun representative. The software implemented its own filesystem - you would set some kind of version label on a directory and then magically all files and sub folders would appear as of that date. This included libraries, binaries, data files, even crash dumps.

This is all from memory, someone can fact check and correct the finer details.

Nice blog post!

Clearcase. Ugh. Only had to use it on one job in the 2000’s, man was it terrible to use. Very slow, required weird file system drivers and access. Horrific GUI. Semantic model was simply broken.

Systems like Clearcase is where “release manager” type roles were born. One poor guy would become the expert trying to bang a release out of it over weeks or months.

ClearCase was basically a spinoff of Apollo's DSEE (same engineers), which didn't need kernel patches, because Domain/OS actually had an object filesystem and so the reference-to-repo was just a filesystem object. (As with ClearCase, it wasn't so much the software cost as the 1-3 FTEs you needed to be sacrificial experts to tune and manage it.) (insert "mimic a fraction of our power" meme here, though that applies to a lot of Apollo stuff :-)

RCS had tags but they were single file tags; the two big things CVS gave you were "this collection of RCS files means something as a whole" (which made tags and branches meaningful) and "you can sort-of-efficiently update from a repo on the other side of the country". (The former was the entire point: CVS was written so Solbourne could maintain their multi-cpu-SunOS fork and still pull changes from upstream; the latter was from Cygnus having a similar upstream+local problem and developers distributed across the planet.)

I used SCCS for a short period before finding RCS. IIRC the commands were a bit different and the files SCCS managed were larger. I also think SCCS had something similar to $Id$, but forgot what it was. Of course I could be miss-remembering.

I also ran across SCCS for Linux somewhere, I forgot where I saw it. Maybe you can look for it and play with it.

I used sccs on Sun workstations back in the 1990s. It wasn’t terrible but if you had more than a few team members then chasing people to check their code in for a build was painful and sometimes you’d hit a point where the project wouldn’t compile because of incompatible changes.

We switched to PVCS which made it easier to have isolated work spaces, plus a bunch of scripts to build those so developers could effectively emulate feature branches. Merging was a bit painful but at least you could work without holding other people up.

I’ve used other tools since but git is damn good compared to those older tools. I do miss being able to embed version strings but in reality tagging is superior if you have disciplined release control.

Feel free to contact me via my profile if you wish.

I have been a solid user of SCCS and successors since SCCS became available out of the box on SunOS.

The delget/deledit pessimistic model of SCCS (and RCS, and CVS?) were poor compared to newer VCSes such as SVN and git.

The pain of getting SCCS (and even RCS) to work for multiple networked users was ... well ... profitable for me at my hourly consultancy rate...

But even SCCS saved me/others from many traumas and detected file corruption (even a failing SCSI disc connection once, IIRC).

As others have mentioned, using SCCS and RCS leaves you constantly having to ask others to unlock certain files so you can have a turn editing them.

Getting groups to move to CVS was hard. Devs were terrified of conflict resolution if they edited the same file concurrently as another dev. Took patient explaining that it would only be an issue if both devs modified the same lines, and even then it would guide you through the experience.

But they did let me, a young engineer, convert them from SCCS to CVS, so yay!

Reply on news.ycombinator.com