First!

Seriously though, I often wonder why "beta" can sometimes seem more like "release" - especially in GMail's case.

About the perpetual beta ... I was attending the Basta.Net conference in Germany. two years ago. And one of the speakers, talking about web 2.0, recommend to stay on beta. Because it makes sure that there is still effort on the project :)

Maybe the Gmail beta is some sort of Google joke?

I think a lot of people use Betas more as marketing tools rather than for testing these days, particularly start-ups and game development.

MySQL uses the Gamma naming :) See: http://www.mysql.com/search/?q=gamma

Does software development stop at gold step ?
What about software that continously evolve, like Team Fortress 2 ?
Still old bugs to fix, but new functionnalities, new bugs,...

I'm also blaming software policy around the "beta" designation.

Seems to me like the perpetual Beta is used as an excuse. If you app messes up and loses someone's information you can always say 'Ah, yes but you understand that we're still in beta'.

Alpha, beta etc have lost all meaning to me in these web 2.0 days...

> Does software development stop at gold step ?
> What about software that continously evolve, like Team Fortress 2 ?
> Still old bugs to fix, but new functionnalities, new bugs,..

Wouldn't that just be the next release/version, which would still have to go through the alpha, beta and Release Candidate stages?

I think in the days of web 2.0 the (web) applications underlie a much greater fluctuation than traditional software. Traditional software goes the way you described it: alpha first, then beta, maybe RC and then you ship it out and have no way to fix anything until the first patch comes along. And even then you don't know whether everybody applies that patch.

But web 2.0 applications always stay at the company. Thus you can release much much earlier. You can play around and try out different things. If they don't work, delete or rewrite them. No patches. Just the software. You never know what your customers want. Maybe you have some great idea but nobody likes it? Or people ask for certain features and you can provide them right there without having to ship patches. And because you never know what the software will look like tomorrow as the web and the applications are constantly evolving the software is never really complete. Sure, traditional software also is never really complete because there will always be bugs but with web applications you don't have that clear distinction between developing and shipping. You ship as you develop.

Small side note: If it doesn't work, well, there is a "Beta" sticker so don't complain.

wow, weird that you should write this - I just made a 'gamma' phase for a project this week for the first time. In this case it was for a significant change made after the project was delivered - feedback functionality need to be provided through mysql instead of a static txt file. Interesting. We used to use 'gold' at the agency I worked at, but I figured it would 'copying' if I used it to, so I figured Gamma would be reasonable.

The perpetual beta thing basically boils down to a lack of confidence on the part of developers. You put up a first go at your site and label it as "beta" to let people know that it is finsihed yet (often also implying it isn't feature complete) and as people use it and start making requests you work a lot on features and never really get around to doing the code freeze stage where you go around and just fix bugs. The developers don't want to stop innovating as they worry that the users will leave and they don't want to take down the beta label as it implies an extra level of quality and robustness that you haven't done the work to achieve yet.

Does the term 'Gold' come from before releasing to manufacturing, we used to burn a load of gold (i.e. blank) cds?

I think the reason for versioning an application as gamma and beyond is to apologize for bugs in advance or to make the users believe, that more features are to come somewhen in the future (even though there are no further features being developed yet).

Where does the CTP fits in? Like in ASP.NET MVC? Is it still at alpha stage?

I once heard the term BETA on a web 2.0 site can save you from trouble. e.g. if you lose you're user's passwords you can always say "well that's why we're still in beta".

I doubt that this makes any difference in front of a judge however...

>Does the term 'Gold' come from before releasing to manufacturing, we used to burn a load of gold (i.e. blank) cds?

Sort of the opposite - it's referring to the single master CD that gets sent to manufacturing. It originally comes from the recording industry -- back in 1901, a gold master was used to copy phonograph recordings. It's interesting that the longest-lasting CDs are also gold; but it appears that the term actually pre-dates CDs by quite a few years.

There's also a reference from Apple using the term "Golden Master" back in 1988 (http://developer.apple.com/technotes/tn/tn1132.html) to refer to the final version of a product. It may not be a coincidence that the first Apple CD-ROM shipped the same year.

Simone: CTP would be public beta, usually in the earlier stages. I remember reading about the way Microsoft handles this (no bets but somehow I think it was on Raymond Chen's blog).

Well, perhaps it wasn't Raymond, but he did explain Microsoft's beta/RC policy in TechNet Magazine (online at http://technet.microsoft.com/en-us/magazine/cc194403.aspx for those interested).

>Does the term 'Gold' come from before releasing to manufacturing, we used to burn a load of gold (i.e. blank) cds?
I'm quite sure these terms predates CD-R's, and I'll guess "Gold" refers to something polished and valuable.

>> One of the most experienced software developers I ever worked with
>> characterized the release candidate development phase thusly:
>> "does this bug kill small children?"

This made me cringe - I develop medical software, sometimes used in pediatric settings. Some of my bugs have the potential to do just that...

GMail Beta is no joke, because Google does this with almost all of their products. I'm surprised that Google Search isn't labeled beta.

Personally, I hate the term "Release Candidate". I've always preferred versioned betas. Once you fix enough bugs and think it is ready to go then release another beta and repeat this cycle until you go gold.

Microsoft did it:
First came Microsoft Windows 95 a (≡ α),
then Microsoft Windows 95 b (≡ β)
followed by Microsoft Windows 95 c (≡ γ)

But they never managed to ship the "gold" version...

Am I getting beta invitation?

Don't forget that those divisions are even further sub-divided:

Beta 1
Beta 2
Beta 3

RC 1
RC 2

...and so on. When you start doing things like that, the boundaries between alpha, beta, community technical preview, release candidate, etc., all just sort of break down.

Who's to say that "Beta 3" isn't really the same thing as a "CTP 2" or whatever?

Although I like using the terms (they sound cool!), we really could all save ourselves a bunch of trouble by just using simplified terms:

Internal Release
Preview Release
Final Release

Because, really, that's all there is. When it's "internal," the labels are irrelevant - as long as the people in your company/organization understand them.

When you release it to the public, but it's not "done" yet, you might as well just call it a "preview." Because that's what it is. Use version numbering (0.0.0.0.1 or whatever you want) to keep track of incremental changes while you are letting the public "preview" it. This covers Betas, community technical previews, release candidates, and the whole lot of "almost done" labels we seem to have come up with.

Then, when you're ready to ship the product (and what exactly does "ship" mean in today's web 2.0 world, where you never actually "ship" a physical product, anyway?), just call it the "Final" release - or just refer to it as 1.0!

That's my $0.57, anyway.

Funny, I was just thinking about this topic the other day.

It really amazes me how many software places and IT shops I run into that don't do _any_ versioning at all. They may have some pie-in-the-sky idea like "this is version 6.0" - but that version 6.0 actually consists of 20 or so different releases which don't have any actual version #.

So I always push the idea of Alpha, Beta, then 1.0, 1.1, 1.2, etc. Scary that they don't understand the concept of a minor version....

>> "does this bug kill small children?"

> This made me cringe - I develop medical software, sometimes used in
> pediatric settings. Some of my bugs have the potential to do just
> that...

I got feelers from a company doing that once several years ago. I figured since bugs could kill people and all, they probably be using something like SPARK ( http://www.praxis-his.com/sparkada/ ), or at least using a realtively safe language like Ada or Java. Or perhaps some other low-risk development system I'd never heard of.

Nope. Vanilla C.

Of course I turned them down with prejudice. Let someone else write code that kills people, I'm not doing it. It does not lend confidence whenever I step in front of an X-Ray machine or slide into an MRI chamber though. You gotta wonder how many undiagnosed pointer dereference errors are floating around in there.

What do you call a collection of many versions of a software product bundled together? For instance if I could purchase all the versions of Adobe Acrobat (1,2,3, . . .) in a bundled package. You know, a total collection of all versions of a prodcut, a sort of a sum of all the versions released in a series. Is that a SIGMA RELEASE?!??! HAHA!!! THE SUM OF A SERIES!!! I AM HILARIOUS!!

Imho releases go like:
Alpha = Not feature-complete
Beta = Mostly feature-complete(but buggy)
RC = Last test, will be rebranded to gold if no critical bugs, assumed to be bugfree
Gold = Final release, same code as last RC

Ancients greeks had a numeric system based on letters, so a=1, b=2

I am working my last day with my current employer today. I ended up giving 4 weeks notice to complete a project to a Beta release. I think we are really still in the Alpha stage since there are a few missing pieces of the software. None that inhibit the successful use of the system, but they were on my feature list for this release.

I decided to move those from the main delivery to the second version. Other than that, the code is complete and works like a champ. I would've preferred about 2 more months of testing and tweaking before releasing it, but it's a solid build.

My fear was that I would leave and they would scrap the past 18 months of development since there was no one to compelte the process. That has happened in the past. So, I rushed the beta release so users could actually see our work and hopefully prod my former employer into a final release of the product. It could backfire on me, but if history holds, I will be blamed for everything that breaks anyway...

WA

When I was at Borland we had a few products actually go into Gamma. At that time they WERE what is now referred to as RC.

Randy

There is quite a lot of software that really needs an Omega release.

> Ancients greeks had a numeric system based on letters, so a=1, b=2

What? They didn't use ASCII? :-)

Gmail (as well as other Google products) remain in beta because it gives them an excuse not to provide full support to end users :-)

Perhaps gamma and delta releases are not commonly used because those word have other meanings to developers. I would be afraid that people might think that my "gamma release" was the release that now included monitor color correction, or that the "delta release" was a small installer that only contained changes from the previous version.

Alpha and Beta designations shift the responsibility for testing to users. Back when versioning was still "en vogue", one could easily figure out how close to being done a product really is. Ever since Microsoft introduced the idiotic term "friendly error messages" and product numbering designed for branding (windows 95 and so on), software quality was getting worse. Name such as "Product XYZ 2008" does not tell you anything about the version or the number of previous releases.

In spite of all the advances in tools and hardware, software quality has gotten worse over the years. Very likely because objective reporting of its completion status was abandoned in favor of branding.

Well, the Wiki article seems to be a precis of the 'beta' entry in the Jargon File:
http://www.catb.org/jargon/html/B/beta.html

One of the developers I work with has this as his email signature:

"Beta doesn't mean 'beta"

Maybe this is because web apps don't have version numbers. So the creators are reluctant to call it "finished".

If you look at GMail you'll see that it is infact still in a beta but not the beta of typical software, as its not typical software. Google rather consistantly makes 'improvements' to GMail, that would not be classed as bugs.

I also think that calling it a beta gives them more of a reason to not charge for this service. "We can't charge for GMail it's still in beta!"

Looks like IBM pioneered yet another computer convention. I've actually always wondered this myself. On a side note, why does the beta symbol look like the German "ss" symbol (ß)?

So StackOverflow.com is almost ready for beta, eh? What does one have to do to be a part of it? ;)

I've not heard "gold" for a while - it's all RTM now (release to manufacturing).

[)amien

I have seen Gamma used at a couple of work places. The last place used it to indicate the sites that got the GA release first. These sites were referred as our "Gamma" sites, and were not necessarily our beta sites.

The other usage I have seen is to call software Gamma instead of Release Candidate.

I think that part of it is the death of the version number in web based software (and to a lesser extent in non-web). Look at all the big web based stuff and you almost never see a version number. What version is Gmail at?

I'm sure that the developers still use version numbers internally and still do releases. At least on the bigger projects; very small project can get away with continuous hacking and throwing it over the wall, but a project the size of gmail must have discrete releases with all the appropriate stages.

But they don't show the version numbers in any prominent places any more. And getting back to the point, once you no longer tell the public about what version you are on and once you no longer make a big deal about releasing a new version, then the whole nomenclature around releases loses its purpose.

I've not heard "gold" for a while - it's all RTM (release to manufacturing) these days.

[)amien

Microsoft likes to use RC0, in place of the "final" beta. I don't quite understand the semantics. I *think* it means: "It was supposed to be another beta but we had to freeze the feature set so it's a pre-RC RC."

Isn't Micro$oft the only company that uses Release Candidate?

So what do you call the just "wait for the X.1" release routine? ;-)

Gold doesn't really work for web projects except in the abstract, since Gold refers to the master made for producing the discs. Final doesn't really work, either, since you're constantly incrementing your code.

The project I'm currently working on (as my job, anyway) is referred to as being in Maintenance. It's done, we might occasionally add new features, but primarily we're fixing bugs. We're pushing for a new version to get all of the technology a little more up to date, but we can do a lot of the technology upgrades under the maintenance phase as well if we get special funding on an item-by-item basis.

A lot of people use the release candidate term, see Mozilla, for example (Firefox 3 is out of RC status now, right?). Using RC0 would probably also be pretty common in places where naming a product that isn't going on the shelf is determined by developers instead of marketing people. In theory there's no real reason why something would remain "beta" if they've done a freeze on it for release anyway, as that's pretty much the definition of release candidate.

I've recently come to believe that there is really no use to label versions as alpha-beta-whatever. There is no such thing as a final gold version as you'll always run into bugs that need to be fixed. That "final" version needs to be patched with another final version and then that one needs to be patched as well. More often than not, developers seem to forget that software needs to be maintained.

The only reason people want to call something a "beta" nowadays is to let the users know that they can touch the software but not blame the developers if it blows up... since y'know... it's in "beta". If I had to decide, all software should be in perpetual beta.

How anyone wants to do their releases is up to the developers with their client to decide how the latter wants their software. The continuous integration crowd wants to do as many releases as they can so that the client can see the benefit of the product and give feedback.

@T.E.D:

If you ever read carefully the Java license, it explicitly says that you SHOULD NOT use Java to do stuff like: health systems, airport/airplane controlling devices, software to control/monitor military or nuclear devices, etc. Even though Sun promotes Java as a "safe" language, they're very humble in admitting their software is far from perfect. And they don't want people using it in these environments for they don't want themselves to be open for suits (negligence suit for not fixing a bug quickly, anyone?)

Besides, SECURITY IS NOT A PRODUCT, IT'S A PROCESS.

You ought to read that sentence a thousand times until you grok it. Read Bruce Schneier's blog for a more expanded explanation if you will.

You can have well developed code, reasonably bug-free, written in plain ANSI-C (not even C++). It's just that you've got to be careful and methodic in your process - that's what the whole CMMI is about. The Linux kernel is very bug-free now, and it's almost pure ANSI-C (plus GNU extensions, plus some assembly sparkled here and there). And I've seen enough buggy code in Java and C# to understand languages aren't a panacea.

@ Matt:
The German "ss" letter, properly called eszet, evolved from medieval scribes' ligatures combining initial/medial "s" lower case letter and "z" letter. Have a look at:
http://en.wikipedia.org/wiki/Eszet

@Matt S: "On a side note, why does the beta symbol look like the German "ss" symbol (ß)?"

Better question: Why does the German "ss" symbol (ß) look like the Greek beta? (Since Greek existed long before German.)

One thing to remember about the term "beta software" is that in the early days of computers, most applications had a single purpose, and had no user interface to speak of. Hence there were really no "minor bugs" -- it either worked or it didn't. So, if you turned something over to a "beta test site" for testing, it was because you thought it was "done".

"Beta Software" == "Release Candidate" == "unless someone complains, these are the bits we are shipping"

Forget greek, let's use honest labels like:

"Vapor",
"Crap",
"You Try It" and his buddy "Try It Again",
and my favorite "We're Done".

Reminds me of Brave New World

Alpha children wear grey. They work much harder than we do, because they're so frightfully clever. I'm awfully glad I'm a Beta, because I don't work so hard. And then we are much better than the Gammas and Deltas. Gammas are stupid. They all wear green, and Delta children wear khaki. Oh no, I don't want to play with Delta children. And Epsilons are still worse. They're too stupid to be able to read or write. Besides they wear black, which is such a beastly colour. I'm so glad I'm a Beta.

I'm pretty certain that the perpetual "Beta" label has cropped up as a CYA (cover your tush) designation. That way, if there are horrific, show stopping problems you can claim "still in Beta! Use at your own risk". Meanwhile, here's our development cycle:

Alpha:
Features are ready for testing. We send out copies to very select customers because we'd like to get feedback on the general approach that we're taking. Do we need to redesign or are we on the right track. Things may blow up horribly.

Beta:
Things are pretty stable and we're looking for feedback on tweaks and bugs. We send out a more generalized release to a larger number of customers in various parts of the world. We typically include a questionnaire that covers all the major new features and asks users to test out their old methods for backwards compatibility testing.

Release Candidate:
Ready to go barring show stoppers. By the time we get to RC-5, this is usually when we discover massive flaws in the fundamental algorithms, huge gaping memory leaks, and thread and cross process synchronization issues. We sweat bullets for a few days and thank our lucky stars that we haven't shipped yet!

Release:
Hallelujah! Out the door with you. Time for a cold beer and some pizza.

Approximately 3 days later:
First patch.......

Actually, I'm being facetious. We have only had to patch one release over the past 3 major releases. I credit the fact that we have the best QC that I've ever worked with.

Nothing beats a high quality <a href="http://tinyurl.com/58fcb7"; >Zeta</a> release.

> Although I like using the terms (they sound cool!), we really could
> all save ourselves a bunch of trouble by just using simplified terms:
>
> Internal Release
> Preview Release
> Final Release

I'd rename that last one to Public Release because as it's abundantly clear nobody likes to claim anything as finished these days. There's always some change in technology to go after. What people should do more of is track features and changes and group them into different releases and have those 3 stages for each release.

Maybe I just like version numbers a bit more then google or whoever. They *do* have versions of gmail above "Old html" and "new", they just don't share that, which is fine by me.

There's no such thing as "Gold" in software. As you mentioned, there are probably still numerous bugs left to be dealt with in the next release or service pack. Of course, there are numerous other features that have not been built. In fact, in my opinion, if there's such a thing as "Gold" in a software, that software is already obsolete by the time it goes "Gold"

What's wrong with "Done" and "Not done"?

Personally, I typically use "preview" or "demo" and then it jumps to just "finished" - even the end users know that "preview/demo" means it's not finished.

> If you ever read carefully the Java license, it explicitly says \
> that you SHOULD NOT use Java to do stuff like: health systems

Yup. I suggest that, for the purposes of this discussion, we take that just as seriously as Bell Lab's (the creator of C)'s assertions to the DoD back in the 80's that C is also not appropriate for such work. How seriously that is, I leave up to you. :-)

(Reference Source: ACM SIGPLAN Notices, Volume 28, Number 3, March 1993, page 314)

> Besides, SECURITY IS NOT A PRODUCT, IT'S A PROCESS.

Actually, I agree entirely with this statement. However, that still doesn't mean that its smart to go into the fight with one hand tied behind your back. In fact, it expressly means that you *don't* do that. If you find someone doing so, how great is the rest of their development process liable to be?

Plain old C has been proven to (yes, proven) to induce more bugs than comparable code written in other languages. In some realms it is just fine to cut corners and use it anyway. After all, you can't beat its industry support. However, anyone using it for safety-critical software when there is a better choice available should be ashamed of themselves.

> Forget greek, let's use honest labels like:
> "Vapor",
> "Crap",

Heh. I like that.

"There are two kinds of software..."

> Forget greek, let's use honest labels like:
> "Vapor",
> "Crap",

Heh. I like that.

"There are two kinds of software..."

GOLD: Yes, the very first release after beta were multiple hard copies and stored in safes, technician and engineers' toolboxes and company archives.

I had always assumed they just stood for 'a' and 'b' releases and the phonetic alphabet was used. So, in that sense, I have used 'Charlie' as a release moniker.

Anyone else ever had a 'Charlie', 'Delta', 'Echo' or 'Foxtrot' release?

> Anyone else ever had a 'Charlie', 'Delta', 'Echo' or 'Foxtrot' release?

No, but I've seen a lot of "Whiskey Tango Foxtrot" releases.

>No, but I've seen a lot of "Whiskey Tango Foxtrot" releases.

"Lima Oscar Lima" - Literally I laughed.

"I had always assumed they just stood for 'a' and 'b' releases and the phonetic alphabet was used."

Except b is Bravo in the phonetic alphabet. But thanks for playing.

I wonder if anyone has used "master beta" for a release? It seems that Googlers are "masters of their domain" when it comes to GMail...

Some software still ships on discs, namely, console video games. Some consoles don't have online updates for boxed games (Wii). In that industry "beta" definitely means "feature complete." Adding features (a.k.a. bugs) at that point is suicide. And, yes, 99% of those games are written purely in C++. Most are also under budgeted and have schedules that don't allow for slippage. Been there, done that, learned the meaning of stress migraines.

1... 2... A... B... Alpha... Beta...

Deviating from the patterned norm would inevitably drive everybody to jump off the highest mountain.

> Of course I turned them down with prejudice. Let someone else write code that kills people, I'm not doing it. It does not lend confidence whenever I step in front of an X-Ray machine or slide into an MRI chamber though. You gotta wonder how many undiagnosed pointer dereference errors are floating around in there.

http://en.wikipedia.org/wiki/Therac-25

The whole alpha/beta naming scheme is an obsolete relic from a different era. An era where all of the features were made in one monolithic group for release on physical media. The features were made first for alpha, and the bugs were fixed afterwards (in subsequent betas, release candidate, whatever).

In this era, new features were only added in a new major version, which will come years later, after their own monolithic testing and release cycles.

For many systems (such as web apps, web delivery, automatic updates/patches, internal corporate apps) it just doesn't need to be done that way anymore. There's no reason other than tradition to hold on to arbitrary forty-year-old labels like alpha and beta. I've stopped using them years ago, and I haven't missed them once.

> You gotta wonder how many undiagnosed pointer dereference errors are floating around in there.
> > http://en.wikipedia.org/wiki/Therac-25

OK, that's one. :-)

Actually, reading over their litany of causes, its funny how similar it looks to those identified for the Ariane-5 lauch failure - http://en.wikipedia.org/wiki/Ariane_5_Flight_501

It even had the exact same direct code cause: an undetected arithmatic overflow. In the Ariane case they were using Ada, so it *should* have been detected. However, they manually turned off the checks in that part of the code. Doh!

beta = beta waves = lots of activity = still developing features.
gold = cold dead metal that some people find value in = legacy

Beta also implies that you shouldn't rely on it, so it's a liability / perception issue. We all know how people love to moan. Beta also implies maybe someone listens to your feedback (and not just some focus group).

Just remember, never realease anything unless it's pretty darn good / fast / polished. Perception is everything. If it looks and acts like a steaming pile of crap, people will be lax to come back. Scaling and speed issues seem to be less of an issue, as people seem to expect that you won't get that right the first time.

If memory serves, the CircleMUD codebase was derived from DikuMUD gamma 1.

When I was making AMXX plugins, I used to number releases using Greek letters where changing the letter meant major feature improvements and incrementing the number was bugfixes only. The furthest I ever got was Theta 4.

At a previous job we used the term "Omega Test" to indicate the "Release Candidate". It had a finality that got tester's attention better than candidate.

> I also think that calling it a beta gives them more of a reason to not charge for this service. "We can't charge for GMail it's still in beta!"

Except Google rarely charge consumers for their service, and I bet the advertisers are paying. Or do you think it is Beta / free advertising? :-)

I read an article over at Yegges drunken blog rants that touches on a couple of points you mention. You mention the phases of a typical software development lifecycle. He believes, and I'm inclined to agree (despite my very limited knowledge) that web-apps fall under a different category. Namely, 'servware'.

Hosting an application means that incremental updates can occur at any time. Bugs can be fixed instantaneously. Testing never stops! The users discover bugs and (hopefully) submit them, and a good application will have them fixed in very short order.

Given this 'new approach' to development, and based on the terminology used.. is a web-app ever out of 'beta'? Is it ever final?

I wonder how the pre-alpha/ alpha/ beta/ RC/ gold release process can be suitably used in agile software development. What are your thoughts on this?

Inder P Singh

What does CTP stand for? It's not like CTP can mean only one thing, wikipedia lists over 20 possible meanings:
http://en.wikipedia.org/wiki/CTP
I hate it when somebody uses a TLA* blindly assuming that everyone will understand what you mean. Very often there's several different meanings of the same three letters that could fit the same contexts.

I guess that in this case CTP most probably is "Community Technology Preview" but it might allso be "Concept To Prototype" (that might refer to a very early stage or something).

My point is: If you use an abbrevation/acronym less known than WWW, URL etc., at least check wikipedia if these letters leads to a disambiguation page or not.

* In this case "three letter abbrevation/acronym", just to show how annoying it is.

The advantage of giving people early code is that their feedback can be more easily incorporated into the project. A beta product that's finished and been through internal testing isn't that likely to change in a major way if an end user comes up with a good idea or finds a major flaw in the way that it works.

I think IE8 beta 1 is a good example. It's not that useful for browsing the web but it gave the web development community a chance to give feedback to the IE team at a point in the development cycle when it could still affect the final product.

> a chance to give feedback to the IE team at a point in the development cycle when it could still affect the final product.

Yes, and in that case, the feedback was "run away screaming"

> I wonder how the pre-alpha/ alpha/ beta/ RC/ gold release process can
> be suitably used in agile software development.

They don't really fit except as labels for iterations. IMO they don't actually match reality all that often.

There is only value in having these steps when the release/install process is hard (eg selling commercial software on CD, updating thousands of users at the same time in a commercial environment etc)

@Inder P Singh:
Even in an agile development you will have a kind of alpha/beta/release.

For instance by using Scrum, at the end you will deliver a featured and stable (deliverable) version of an application.

Means during a sprint you will reach a test system. There you will run feature tests and regression tests. After tested ok on test, you will move to a beta environment and do the same testing (beside of that you may have stress tests, too). And after tested ok on beta, you will have a release candidate - even if this does not mean that you will release it, because you need several sprints to inlcude all features.

As some people have pointed out in comments already, the term "Release Candidate (aka gamma or delta)" is a non-sequitur. Either it is a candidate for release or it isn't. Betas are never simply re-branded "final" if they're found to be bug free (if they can be re-branded without change, they aren't betas! Betas should be lacking the necessary fluff that wraps a final version, like a spell-checked README, a nice logo, etc), but RC's are. That's the difference. The term "Release Candidate (aka gamma or delta)" makes it sound as if the next letter in the alphabet is simply "the next version", which would turn the whole system of release classifications into fuzzy jelly, don't you think?

So, article writer, here's hoping you'll adopt the views of the software community outside Redmond/Mountain View, and stop using the term "Release Candidate (aka gamma or delta)".

I always used delta as the pre-alpha version designation. Greek letter delta standing in for "development".

Haven't heard 'Gold' myself, but I've heard 'GA' (meaning generally available) used recently by IBM among others.

As previous posters have said, Gold referred to the master sent to manufacturing. It was usually magnetic tape before CDs existed. In the enterprise software business, RTM (release to manufacturing) and GA (General Availability) are the most used terms. Of course, now there is almost no manufacturing, so GA is the dominant term. I used to hear Gold primarily at PC software companies in the 90s.

I would differ slightly on the definitions Jeff gave. I think Alpha should mean functionally complete and passes all developer testing and initial QA testing. Beta should mean that it passes enough QA testing to be used more widely. After, alpha, the only changes should be bug fixes. Of course, my definitions don't fit the "web 2.0" mode of continuous changes.

I have heard Gamma used instead of RC, but very infrequently.

Yeah, RTM seems like a bit dated. Isn't RTW ("Release To Web") the new, trendy Web 2.0-ish term?

@Jeff & T.E.D.: Wired lists several more

http://www.wired.com/software/coolapps/news/2005/11/69355

Just for trivia's sake...

"Release Candidate (aka gamma or delta): The software is almost ready for final release"

I so hate this definition! (although this seems to be the meaning in the industry).

In my book "Release Candidate" is exactly that: I really, truly believe this is ready for release. All the bugs that I know of are not going to be fixed for the final build. If no new major bug is discovered in this build, then this is the Gold!

So "Gold" is not a special build, it is "putting the official stamp" on the last Release Candidate. And the last RC becomes the Gold.

John:

Some of those weren't really that impressive, but man oh man how did I miss this story? : http://www.msnbc.msn.com/id/4394002

Apparently the CIA actually managed to put a bug in the Soviet natural gas pipeline control software back in the early 80's that caused an explosion large enough to see from space!

The best part of it is that they didn't hack anything in Russia; they just slipped the bug into some software they new the Soviets wanted to steal. That way they couldn't even complain about it. :-)

I demand perfection. What am I supposed to do with love that is not perfect? Like the features don't work nicely but hey, they love me?!

I actually never heard the term gold for final release. Just to know that it was released or that I/we released was enough.

Remember the joke: The support technician told a customer that they couldn't help them because the software was in gamma testing release, even though they payed money for it. The joke being that purchased software is just in another testing phase. Makes me feel great as a consumer.

I never knew that gamma was another term for release candidate.

Thanks Jeff,

The way I have always heard the terms used is that alpha testing is private and in-company; beta testing involves releasing the product to (some) users outside the company.

Different kinds of product have very different test cycles. For example, console video games typically do not undergo beta testing: members of the public don't get to see the game until its release. On the other hand, many free software projects have essentially no alpha testing other than that done by the programmers as they work: these projects rely completely on public beta testing.

A "gold" release is one that is final in some way, or that is expensive to recall, for example a console video game that has gone to manufacture or distribution. Software that users update on a regular basis has no need of "gold" releases: the developers can always make another version available.

@Ortzinator Web applications do have release numbers, or at least they should have. Any site developed with even slightly more advanced release planning than directly editing the code on the production server should have some way of distinguishing different versions. However, the version number is often only used for internal purposes and is never communicated to the user. You typically don't see a changes.txt file on most web sites.

I see a lof of people argue that the alpha and beta labels are useless with the current practice of incremental releases and frequent updates to web sites and software. Personally I think version numbers are better suited for that. For example, you could have version 1.0 alpha, 1.0 beta, 1.0 release candidate and 1.0 (final). When you add new features you go to version 1.1 alpha, 1.1 beta and 1.1 (final), and so on. If you always stay in beta and go directly from 1.0 beta to 1.1 beta, you are basically not completing the full release cycle for each update, possibly resulting in software with more features but lower quality.

I think the alpha, beta and release candidate labels still have some uses, but what they actually mean to a certain team or product may have to be defined specifically for each situation. For example, a team may decide that no new features can be added to the product after beta, or that after release candidate only bugs classified as critical will be fixed. This may or may not have any actual value to the end user.

I can't believe no one's mentioned how Textpattern was in gamma for a long time.

P.S. Blackletter as CAPTCHA? Really?

That's funny, I wrote about this two years back (doesn't feel like it, though). I can't believe GMail is still called "beta".

The Amiga OS releases (Workbench / Kickstart) had gammas.

thanks for showing us the front door in your 1st august comment

"If you’re curious about the “programmer” design, Kevind Deloach was kind enough to send in this screenshot he captured

http://blog.stackoverflow.com/wp-content/uploads/stackoverflow-alpha.png
" which shows the url for the beta. now please please get me the key. sorry for this unorthodox method but you did say you read all comments.

I see a lof of people argue that the alpha and beta labels are useless with the current practice of incremental releases and frequent updates to web sites and software.

I actually never heard the term gold for final release. Just to know that it was released or that I/we released was enough.

oh boy!!! it makes me remember of doing maths on alpha beta..i loved alpha beta ;)but in maths too we never used the gamma term

As far as I know that these came from old greek language.

Websites/Web applications are NEVER "done". The release cycles of every Web company I've ever worked in had new code updates at least once a week. For a long time at Amazon.co.uk we did code updates to the live site EVERY DAY! Major feature releases might only happen once every month. Oo-ah!

So, the idea of Web2.0 sites being in permanent beta is a bit silly, I think. Once you get over the initial hump of actually having a functioning application with a releasable (and usable) set of features that you can let the public play with (as opposed to just a select group of people) then you are no longer in beta. You are in production.

The worst thing about the permanent beta is that it lets programmers and managers at some companies think that they can let lesser quality code out onto their production servers because they think that "it's just beta, and people know that." No. BS. People are USING YOUR SOFTWARE. Have a little self respect and respect for your customers. Give them software that's been properly tested in house and/or amongst a *small* group of hard-core beta testers (on a separate server) before you push those changes to live.