Ask HN: What was OSS like before Github?

[wavetwista]

Just a question I thought of this morning.

I was introduced to open-source through Github (I know, I'm young and green), I have no context about what it was like beforehand, I thought pull-requests were a core git feature and Github just put a nice wrapper on them :)

So, when you found a bug in OSS pre-Github/Bitbucket et-al, how would you fix it? Where would you discuss it, on mailing lists? And when it was fixed/merged, how would you inform people what had happened, why, and how the changes might affect them?

[moreentropy]

Guys, Git and Github are just tools. Even if Git nerds would like you to think that software can't be developed without github, it worked before.

We had sourceforge, berlios, tigris.org etc. for years if you like your project hosted. Then there's Trac, Redmine etc. Otherwise you'd set up a Mailman for mailing lists and subversion as source code repository. If someone attaches good patches to mails and/or gives valuable input to the project, he usually got write access to the svn repository.

I'm not even sure that the Github way of developing OSS is that much of an improvement. Too often people rather fork than contribute. You'll find a dozen forks of the same software where different people fixed various things, half of them abandoned a long time ago and none of them usable.

[samrift]

The bar to entry was much higher, both for a project and a potential contributor. But that's not just because of no github

Projects had to find a home (sourceforge ended up a major player here) and for most, fill out some large form to be accepted. Then they had to get noticed - slashdot or similar, since there was very little "social" effect on the project host.

When a project did try to get noticed, it had to already be "good" enough to get people interested. Practically nobody would stumble on a half-implemented tool, because there was nowhere to stumble there from. And it wouldn't get the push and discussion on newsgroups or websites if it was half-implemented.

Contributors had to first find the active developers. Many times, that was not on the issues list or a newsgroup, but on an irc channel mentioned in passing in a readme file or on a newsgroup ("I was talking to bud on #ourproj about the thread scheduler..."). Once you found them, you could try to "break in".

Since 95% of the OSS projects you'd actually find were already "good enough", that meant there were already a good number of active contributors that had formed a clique and were understandably protective. In many cases, you had to work hard to get them to accept that you might help rather than be a burden. That meant hanging out on irc or newsgroups and trying to impress.

Once a project was abandoned, there was nearly no way to contribute, you'd have to fork it. Unfortunately, your fork would have to beat the searchability of the original project with even more buzz, or people would find the abandoned one and have no inkling that your fork existed.

Obviously this is an over-generalization... there's no way to really encompass how all OSS was, even if I knew -and many major OSS projects were not at all like this, since each had it's own ecosystem and quirks.

In general the discovery of projects, and the ability to contribute, has grown in leaps and bounds around the time of github. But that is due also (to a very large extent) to other tools such as blogs, social sites, news sites (eg hacker news), and better search with google. Really, github is just a part of a huge increase in online interaction between people.

[m0th87]

I was using OSS only briefly before github, so at that point at least tools existed: sourceforge, google code, etc. But it was hell. Seriously.

The use:contribution ratio was totally skewed. Few people left commentary or filed bug reports when an issue arose, mostly because every project had its own way of handling feedback, and oftentimes you had to separately register or join a mailing list to use it. Pull requests didn't exist, so instead if you were feeling really ambitious you might attach a patch file to the ticket you opened.

And then there was the act of creating a project. Google code improved this significantly, but I remember having to file an application to get approved for an OSS project on sourceforge back in 2004. And it was a seriously long application too!

[mattl]

> Over the last decade, free software developers have been repeatedly tempted by development tools that offer the ability to build free software more efficiently or powerfully.

http://mako.cc/writing/hill-free_tools.html is worth a read.

[anywherenotes]

For an example you can look at http://www.xmlsoft.org/downloads.html That's a website for a highly used libxml2 library. I believe you would still just send your patch to the mailing list, or possibly the main person in charge.

So big or non trivial projects had their own websites, and mailing lists. I don't really know what a small project would have. For example yesterday I made a page that converts any time in human readable format into local time. (useful for when you get email for a meeting in some awkward timezone) Since now we have what we have, I put it in bitbucket, few years ago, I would just have the source on my PC until it gets lost.

[dedward]

While there was of course great variety... the most common would have been an email mailing list.

Maintainers of a piece of software would run some kind of VC repository usually, although not usually a distributed one like GIT - they were networked. Some people had commit access. You'd keep a changelog, just like today, and the group would tag and release, just like today.

What Git/Github brings to the table is really the combination of a distributed version-control system that gained large traction (GIT) and a system to leverage that to make common collaboration tasks easier (fork, pull request, tracking meta-data, etc).

[tirant]

Before github, we had sourceforge, berlios, savannah, and before that, I used freshmeat to keep track of a lot of opensource projects I was interested on. Each of them having their own repo / ftp.

[taf2]

It may have been just the time or the community but I felt like IRC was way more involved in open source development. It probably still is - but I can remember learning and asking questions and helping answer some on #gtk and #mozilla IRC was where it all happened... I'm sure this is still the case and it's mostly my lack of involvement now as compared to then, but it was pretty fun...

[terabytest]

Well, before GitHub there were things like Google Code or SourceForge, which I think worked pretty much the same (albeit probably not as noob-friendly). Before those it was probably self-hosted servers for the bigger organizations or something like that, although I'm only speculating.

[skinnymuch]

Isn't Google Code sort of in the same "generation* as Github versus much older Sourceforge? I dont think Google Code was around during the first year of Google going public back in 2004/2005. Anyway not actually sure just how I've always thought of social version control sites.

[infinii]

Guys, don't forget www.freshmeat.net I still get a good chuckle when I recall the day our admin called me with this voice of concern about my surfing habits. He obviously hadn't clicked on the link but thought I was surfing porn in the office.

[grumps]

Well I can't say that I was paying attention a lot until the past few years but I think would could use Debian as an example of it. obviously a very mature project with funding of sorts.

[a3n]

Sourceforge. Patches and communication over mail lists, or over usenet. Gopher.

And you used to get your unix on tape, with included tools and apps.

[Shorel]

We used to send patch files over email to the inner sanctum of approved project maintainers.

Or, at the very least, I did.

[talles]

SourceForge & mail lists. Little bit of freenode also.

Google code never really hit mainstream IMO.