Hacker News Reader

Comment by AYBABTME | Hacker News Reader

Trivia: This code is older than many of the readers.

https://github.com/mirrors/gcc/blame/7057506456ba18f080679b2...

That's beautiful. It may be a monster, but it started so small in 1992 - then was grown with loving care in 1993, 1994, 1995, 1998, 1999, 2001, 2002, 2004, 2005, 2008, and 2011!

It was 16 lines in 1992. I guess that's not what it is today, but not exactly "so small". https://github.com/mirrors/gcc/blob/42c63e4d48cfac192be8c0cc...

The copyright notice goes back to '87. I wonder if '92 is just where the source control kicks in.

I thinks that's just when the source control kicks in.

DannyBee claims that reload was started in the late 80s.

There are commits going back to 1988, but it looks like a lot of the early commits are out of order; the repository was (at least) converted from RCS to CVS to SVN to Git.

I'm impressed that the blame log has survived intact. What SCM was originally used?

So, i converted the repository to SVN (which is what this is based on).

Originally? None.

Then RCS

Then it forked into EGCS and GCC, and EGCS used CVS

On remerge, we used CVS.

Then we converted to SVN.

I basically rewrote large parts of cvs2svn to make this happen (before that it took weeks to convert and ran out of memory anyway :P)

During cvs2svn conversion, the old GCC RCS versions we had data for were inserted as branches and older revisions, as appropriate

Since the original per-file version numbers were not kept, this was done by inserting it and then incrementing existing version numbers on the RCS files that made up the CVS repository, and hacking up the cvs2svn parser slightly to allow for some idiosyncracies (because now you have a billion years worth of RCS bugs to parse)

So basically, history goes back as far as there were version control systems that were being used, which is roughly 1987

Before someone asks why it got moved to SVN, at the point at which we converted to SVN,

1. git was not popular yet (or all that usable yet for that matter)

2. GCC's biggest VC problem was needing single repository version numbers for tags, and atomic commits, which SVN solved.

SVN was a huge step forward compared to CVS.

> Originally? None.

Although note that a lot of earlyish GNU codebases kept tons of older versions of source files around in the form of Emacs versioned backup files, and there were RCS-conversion scripts that would commit all of those as RCS versions...

[There would be no log messages for those older versions, of course, but the writers and creation dates of the older files were potentially available... I don't really remember whether those conversion scripts actually used that info or not, although I think they did...]

When I started working on gcc 1.36 (company I was working for was designing Unix workstations and we were fixing the backend for MC680x0) we used RCS. But I'm not sure it was the original SCM, we didn't even have Internet access then :-) And we got gcc 1.35-36-37 "smuggled" to us on the 1/4" tape.

I was a MC680x0 maintainer back in those days. Also picked up i860 for the gcc 2.x stream. Fortunately I was at UMich in the gcc 1.x time, and we had NSFnet.

And yes, I used RCS when working on the gcc source.

Nice to meet you! :-) I still (barely) remember one bug which gave me a hard time - when compiling for 68030, I believe, under certain conditions gcc put floating point variables initialized with a constant into the constant segment. Which caused access violation when code tried to put something else into this variable. Or something along these lines, when was that, 25 years ago? Circa 87 or 88.

We used 860 (not sure) and 960 (definitely) too for other products.

Probably RCS http://www.gnu.org/software/rcs/; It's a fact that it used CVS, then SVN at some point (see https://gcc.gnu.org/viewcvs/gcc/branches/CYGNUS/, a branch created by cvs2svn, a migration tool)

EDIT: Apparently all previous history was lost when they implemented CVS, circa 1997. We could always ask someone in the oldest maintainers file available (https://gcc.gnu.org/viewcvs/gcc/trunk/MAINTAINERS?revision=1...) and have the real answer.

Your last part is not correct. We had the "old-gcc" RCS files, it just was in a format not parseable by CVS. It was not entirely lost, just not easily accessible. Ian Taylor went to the trouble of rewriting the RCS files CVS had, and that we based the SVN repository on, to include the old data, so actually, SVN had more history than the CVS versions, dating back to 1987.

Probably Git? You know that's been around much longer than Github has, right.

Git was released in 2005. Git is only 3 years older than Github

Hasn't been around _that_ long. Wikipedia puts the release date in 2005.

Of course, but even without checking Wikipedia, I remember a time not too terribly long ago when git, and even svn, didn't exist.

And are pretty sure that GCC was around at that point!

By 1992 I had already graduated...

Great. Now I feel a million years old...

1992.. older..

Now I feel old.

This code is one month younger than me.

Since it's trivia we're dealing with. This commit was made 18 days before I was born: https://github.com/mirrors/gcc/commit/cbbca02e2430b2dc1f5681... :)

Reply on news.ycombinator.com