programming and human factors
by Jeff Atwood
As we begin the private beta for Stack Overflow later this week, I wondered: where do the software terms alpha and beta come from? And why don't we ever use gamma?
|
|
|
Alpha and Beta are the first two characters of the Greek alphabet. Presumably these characters were chosen because they refer to the first and second rounds of software testing, respectively.
But where did these terms originate? There's an uncited Wikipedia section that claims the alpha and beta monikers came, as did so many other things, from the golden days of IBM:
The term beta test comes from an IBM hardware product test convention, dating back to punched card tabulating and sorting machines. Hardware first went through an alpha test for preliminary functionality and small scale manufacturing feasibility. Then came a beta test, by people or groups other than the developers, to verify that the hardware correctly performed the functions it was supposed to, and that it could be manufactured at scales necessary for the market. And finally, a c test to verify final safety. With the advent of programmable computers and the first shareable software programs, IBM used the same terminology for testing software. As other companies began developing software for their own use, and for distribution to others, the terminology stuck -- and is now part of our common vocabulary.
Based on the software release lifecycle page, and my personal experience, here's how I'd characterize each phase of software development:
The software is still under active development and not feature complete or ready for consumption by anyone other than software developers. There may be milestones during the pre-alpha which deliver specific sets of functionality, and nightly builds for other developers or users who are comfortable living on the absolute bleeding edge.
The software is complete enough for internal testing. This is typically done by people other than the software engineers who wrote it, but still within the same organization or community that developed the software.
The software is complete enough for external testing -- that is, by groups outside the organization or community that developed the software. Beta software is usually feature complete, but may have known limitations or bugs. Betas are either closed (private) and limited to a specific set of users, or they can be open to the general public.
The software is almost ready for final release. No feature development or enhancement of the software is undertaken; tightly scoped bug fixes are the only code you're allowed to write in this phase, and even then only for the most heinous and debilitating of bugs. One of the most experienced software developers I ever worked with characterized the release candidate development phase thusly: "does this bug kill small children?"
The software is finished -- and by finished, we mean there are no show-stopping, little-children-killing bugs in it. That we know of. There are probably numerous lower-prority bugs triaged into the next point release or service pack, as well.
These phases all sound perfectly familiar to me, although there are two clear trends:
In the brave new world of web 2.0, the alpha and beta designations don't mean quite the same things they used to. Perhaps the most troubling trend is the perpetual beta. So many websites stay in perpetual beta, it's almost become a running joke. GMail, for example, is still in beta after over four years!
Although I've seen plenty of release candidates in my day, I've rarely seen a "gamma" or "delta". Apparently Flickr used it for a while in their logo, after heroically soldiering on from beta:
"loves you" is certainly more fun than "gold", but I'm not sure it's ever the same as done. Maybe that's the way it should be.
Anyone else ever had a 'Charlie', 'Delta', 'Echo' or 'Foxtrot' release?
No, but I've seen a lot of Whiskey Tango Foxtrot releases.
T.E.D. on July 31, 2008 2:03 AMNo, but I've seen a lot of Whiskey Tango Foxtrot releases.
Lima Oscar Lima - Literally I laughed.
CruelShoes on July 31, 2008 2:15 AMI 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.
Noitall on July 31, 2008 2:32 AMI wonder if anyone has used master beta for a release? It seems that Googlers are masters of their domain when it comes to GMail...
Mark S. on July 31, 2008 2:39 AMSome 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.
steve on July 31, 2008 2:52 AM1... 2... A... B... Alpha... Beta...
Deviating from the patterned norm would inevitably drive everybody to jump off the highest mountain.
David McGraw on July 31, 2008 3:06 AMFirst!
Seriously though, I often wonder why beta can sometimes seem more like release - especially in GMail's case.
Matthew on July 31, 2008 3:13 AMAbout 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 :)
Juergen on July 31, 2008 3:17 AMMaybe the Gmail beta is some sort of Google joke?
Stephen Hill on July 31, 2008 3:19 AMI think a lot of people use Betas more as marketing tools rather than for testing these days, particularly start-ups and game development.
Mike on July 31, 2008 3:24 AMMySQL uses the Gamma naming :) See: http://www.mysql.com/search/?q=gamma
David Cumps on July 31, 2008 3:30 AMDoes 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.
TiTi on July 31, 2008 3:33 AMOf 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
Jeff Atwood on July 31, 2008 3:34 AMSeems 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...
Andrew on July 31, 2008 3:46 AM 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?
Steven Bey on July 31, 2008 3:47 AMI 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.
wh on July 31, 2008 3:50 AMwow, 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.
matt on July 31, 2008 3:54 AMThe 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.
Mat Scales on July 31, 2008 3:55 AMThe 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.
Martin Cron on July 31, 2008 3:57 AMDoes the term 'Gold' come from before releasing to manufacturing, we used to burn a load of gold (i.e. blank) cds?
IainMH on July 31, 2008 3:58 AMI 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).
Markus on July 31, 2008 4:00 AM 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!
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...
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.
robot on July 31, 2008 4:30 AMIf 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.
Jack on July 31, 2008 4:33 AMDoes 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.
Krenn on July 31, 2008 5:13 AMAt 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.
JC on July 31, 2008 5:35 AMDoes 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...
cp on July 31, 2008 6:09 AMGMail 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.
Billkamm on July 31, 2008 6:49 AMMicrosoft did it:
First came Microsoft Windows 95 a (#8801; #945;),
then Microsoft Windows 95 b (#8801; #946;)
followed by Microsoft Windows 95 c (#8801; #947;)
But they never managed to ship the gold version...
Chris on July 31, 2008 7:12 AMAm I getting beta invitation?
Thejesh GN on July 31, 2008 7:16 AMDon'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....
Sam Schutte on July 31, 2008 7:26 AMdoes 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!!
Luke on July 31, 2008 7:31 AMImho 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
Nikos on July 31, 2008 7:49 AMI 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
Wayne on July 31, 2008 7:51 AMWhen 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
Randy Magruder on July 31, 2008 7:52 AMAncients greeks had a numeric system based on letters, so a=1, b=2
What? They didn't use ASCII? :-)
T.E.D. on July 31, 2008 8:06 AMI 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? :-)
Peter on July 31, 2008 8:07 AMGmail (as well as other Google products) remain in beta because it gives them an excuse not to provide full support to end users :-)
Dan on July 31, 2008 8:31 AMPerhaps 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.
Jeremy Bettis on July 31, 2008 8:47 AMAlpha 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.
BugFree on July 31, 2008 8:52 AMWell, 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
Brandon on July 31, 2008 9:10 AMMaybe this is because web apps don't have version numbers. So the creators are reluctant to call it finished.
Ortzinator on July 31, 2008 9:13 AMIf 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!
Arron on July 31, 2008 9:13 AMLooks 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? ;)
Matt S on July 31, 2008 9:14 AMI've not heard gold for a while - it's all RTM now (release to manufacturing).
[)amien
Damien Guard on July 31, 2008 9:14 AMI've not heard gold for a while - it's all RTM (release to manufacturing) these days.
[)amien
Damien Guard on July 31, 2008 9:15 AMMicrosoft 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.
David Moisan on July 31, 2008 9:22 AMIsn't Micro$oft the only company that uses Release Candidate?
Mattkins on July 31, 2008 9:52 AMSo 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.
Spoike on July 31, 2008 10:24 AM@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.
Joe on July 31, 2008 10:25 AM@ 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.)
KenW on July 31, 2008 10:50 AMOne 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
James Curran on July 31, 2008 10:51 AMForget 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.
Eric Kibbee on July 31, 2008 11:12 AMI'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.
Steve on July 31, 2008 11:26 AMNothing beats a high quality a href=http://tinyurl.com/58fcb7 Zeta/a release.
Charles on July 31, 2008 11:28 AMI 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?
`Josh on July 31, 2008 11:29 AMI 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
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.
Francis on July 31, 2008 11:55 AMThere'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
Kevin Le on July 31, 2008 12:01 PMWhat'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.
Morning Toast on July 31, 2008 12:01 PM 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.
T.E.D. on July 31, 2008 12:31 PM Forget greek, let's use honest labels like:
Vapor,
Crap,
Heh. I like that.
There are two kinds of software...
T.E.D. on July 31, 2008 12:34 PM Forget greek, let's use honest labels like:
Vapor,
Crap,
Heh. I like that.
There are two kinds of software...
T.E.D. on July 31, 2008 12:36 PMGOLD: Yes, the very first release after beta were multiple hard copies and stored in safes, technician and engineers' toolboxes and company archives.
PaulG. on July 31, 2008 12:43 PMWhat 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.
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?
CruelShoes on July 31, 2008 1:15 PMI 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?!
Silvercode on August 1, 2008 2:08 AMThe 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.
Helen on August 1, 2008 2:33 AMa 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
Jeff Atwood on August 1, 2008 2:42 AMI 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,
Michael C on August 1, 2008 2:57 AM
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)
Jim Cooper on August 1, 2008 3:39 AM@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.
Juergen on August 1, 2008 3:40 AMAs 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).
Anonymous Coward on August 1, 2008 4:19 AMThe 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.
Gareth Rees on August 1, 2008 6:03 AMI always used delta as the pre-alpha version designation. Greek letter delta standing in for development.
spotcatbug on August 1, 2008 7:31 AMHaven't heard 'Gold' myself, but I've heard 'GA' (meaning generally available) used recently by IBM among others.
Asgeir S. Nilsen on August 1, 2008 7:52 AMAs 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?
Craig on August 1, 2008 10:49 AM@Jeff T.E.D.: Wired lists several more
http://www.wired.com/software/coolapps/news/2005/11/69355
Just for trivia's sake...
John Baughman on August 1, 2008 10:51 AMRelease 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. :-)
T.E.D. on August 1, 2008 11:52 AM@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?
Hans E Hyttinen on August 3, 2008 10:18 AMThat's funny, I wrote about this two years back (doesn't feel like it, though). I can't believe GMail is still called beta.
analytik on August 4, 2008 5:12 AMThe Amiga OS releases (Workbench / Kickstart) had gammas.
stevex on August 4, 2008 7:42 AMI actually never heard the term gold for final release. Just to know that it was released or that I/we released was enough.
Marvin Marks on August 5, 2008 1:55 PMWebsites/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.
Lisha Sterling on August 12, 2008 2:13 AMThe comments to this entry are closed.
Subscribe in a reader
Subscribe via email
|
|
Traffic Stats |