Slashdot Mirror
What constitutes an Alpha-version?
jacobm writes "An article went up on mozillazine.org yesterday in which the Mozilla team asks the community: what will it mean for Mozilla to be alpha? Probably a good question for everyone to think about, especially those of us who develop (or will develop) software for fun or profit. " Interesting question, especially when it comes to Mozilla. With M12 coming up, they are getting close to that stage, and have setup a criteria they think works. Do you agree?
I work in the machine tool industry, where MTBF is measured in thousands of hours.
Consider what's acceptable, given the target market for the product. A Web browser doesn't need thousands of hours of uptime, or even tens of hours -- for one thing, Windows will crash sooner than the browser will, anyway. :)
Unlike a piece of machining hardware, a Web browser is not something that people will use all day, and depend on to get their work done. As applications move from the desktop to the Web, ....
Errr, wait a minute...I just realized something...
In the webshell/embed/gtk/ directory of the Mozilla source tree, there's a widget that lets you embed the Mozilla layout engine in GTk+ software. There are also some examples in webshell/embed/xlib/ for GTk+, Qt, Motif, and Xt, but I don't know if they're still maintained or not.
The main diffrence there is, that when a tool fails, you need to buy a new one, when an app dies, you just need to restart it. Its really just an annoyance in somthing like a web browser. You loose your place, but you'll probably be able to get back to where you were in just a bit.
I doubt the MTBF of those machinese you're using would be so high if they didn't cost anything to replace (in cost or time lost)
--
"Subtle mind control? Why do all these HTML buttons say 'Submit' ?"
ReadThe ReflectionEngine, a cyberpunk style n
My mother (bless her heart) would fall under the the "all kinds of frantic link-clicking through all kinds of weird-ass CSS2/HTML4/JavaScript" simply because she has no idea what the pages' content contains untill the link is done loading. Look around, "view source" on the top 20 sites around the net. View Source on some personal homepages . . this 'weird-ass frantic' content is pretty normal, and (thankfully) has been part of the smoke test in the Milestone builds.
I was under the impression that these milestone builds of Mozilla were, in fact, alpha.
My idea of the definition of alpha was something like "it runs on my computer, and if you're lucky it'll run on yours too".
More generally, it would be a piece of software that should be a usable product, but may be lacking some features, experience crashes, or not work at all, but you knew that when you got it.
Obviously I'm wrong, since (a) Netscape feels the need to call Mozilla "pre-alpha", and (b) my definition would include all versions of Windows.
--
Win dain a lotica, en vai tu ri silota
You see, this, as everything, is a question of compromise. Do you want to wait another few years until they can get it absolutely perfect without any outside help, or do you want a pre-release that will be widely circulated so that they can see how the code in its current state stands up to real-world use and abuse, potentially accelerating the bugfixing by several orders of magnitude?
Your comparison with machine shop equipment is bogus. Downtime on such gear is extremely expensive and nearly intolerable. If your browser crashes, you sigh and kick it back up. Nevertheless, I will agree that an hour MTBF is completely unacceptable for a true release. Fortunately, thanks to open source development, it doesn't have to be.
And please, it's "horribly inadequate". Isn't it embarrassing to put glaring spelling mistakes in bold?
Steve 'Nephtes' Freeland | Okay, so maybe I'm a tiny itty
I believe that if this number is moved up NOW,in the alpha phase, it will become even better in future releases. If that number is left where it is, I garantee you that the MS FUD machine will pound that point hard and often. Let's not give them that stick.
Stability (User:it just works) is a shining downfall of IE and and the micros~1 platform. We should aim to be better than that. It's this focus on stability that has gotten PERL, Linux and Apache to where they are today, and I think the Mozilla team should use the same idea.
I'm not asking for 'four nines' in an alpha version, but there must be some middle ground somewhere.
pre-alpha means programmers only (and just for bug testing).
Alpha means it goes to internal testers. That can either be professional testers, or other engineers who have not been involved in the project before. This is where you find 'brown paper bag' bugs that seem to only be findable by people who DON'T know the internals of the software.
Beta means the testers aren't hitting bugs anymore during test use. Now you put it into actual use, but don't bet your life on it. More experianced users may be included here.
In general, each stage should repeat each time bugs are found. So, you release a first beta, and bug reports come back. The bug fixes go in, and are tested by the programmers, and then must pass through 2nd alpha. Once it can pass 2nd alpha, you have the second Beta release. That release can either become gold (1.0), or go through the loop again, depending on the type and severity of the bugs (only small ones!). Note that a 1.0 might still have mis-features, and missing features (that were not planned, there are features whose need was not anticipated by the designers) but shouldn't have bugs (it will since there's no such thing as 100% assurance, but that's the goal anyway).
mis-feature = 1.it does what it's supposed to do, even if it's not what the user expected.
The terms are a little harder to define for Free Software than for commercial, since many beta and gold users will mis-identify themselves as alpha testers. There is a much blurrier line between the phases since you can't define it by who writes the user's paycheck/ what department does the user work in.
Many of you will note that the standards described above would mean that a great many version 4.01743619746 commercial products out there are actually more like 4th beta.
I'm not disagreeing. But as I've seen it used currently the distinction is:
Alpha means the feature set may change before release.
Beta means the feature set is frozen.
That's very slight distinction from the above definition - features may also be eliminated.
Of course, alpha is also earlier and expected to be more buggy than beta.
Alpha is to get it into people's hands when major chunks are known not to be working - both to debug the things that are there and to debug the choice of features and the interface to them.
Alpha isn't just a matter of missing features. Sometimes a feature turns out to be a "misfeature": confusing, counter-productive, or actively hazardous. Sometimes a feature is redundant with another, and may be dropped in favor of one that is easier to use, or more powerful and general. (And sometimes a redundant feature will be added as a simplified shortcut for the more general feature.)
Between alpha releases the user interface may be significantly thrashed or even totally replaced. Even underlying communication protocols and file formats may be modified or replaced.
At Beta the choice of features is frozen. The interface may change slightly (be "tuned"), but this will normally be minor tweaking rather than a significant change in appearance. Protocols and file formats have assumed their final count and basic form, and may even remain compatable between releases.
But don't count on it. During Beta the hope is that everything is there, frozen, but probably needs bug fixes. But if there's a really serious problem with something, there might be a thaw.
Essentially, the difference between Alpha and Beta is management intent: In Alpha, design suggestions might be considered for V1. In Beta, they will generally be ignored - but might be considered for V2.
Bantam Dominique roosters crow a four-note song. Once you've heard it as "Happy BIRTHday" you can't NOT hear it that way
After W2k beta release there was RC1 and RC2, just another name for Gamma1 and Gamma2, right?
After RC1 and RC2 we should have Win2k, which is another name for Delta, right again?
And after you have the final release, calle dSP something by MS.
The biggest difference between the different alpha/beta/gamma/delta releases is the price of the beta (or gamma, or whatever).
"The obvious mathematical breakthrough would be development of an easy way to factor large prime numbers." Bill Gates,
Once we've done that, we start adding in mood. "If only he weren't so ignoraretur!" :-)
Yikes! does that mean they're all female, as in "alumnae"?
hawk, who learned to be careful about greek & latin endings when taking classes from Jesuits who were fluent in both
1. Quality: Mean Time Between Failures should be at least 1 hour. The MTBF for the M11 release was 1.09 hours according to talkback reports (the "fullcircle" in (LINK) means that build reports crash events via a "talkback" component).
That seems reasonable and have achieved this with certain builds.
2. Architecture: Alpha should be "almost architecturally complete". "Almost" is a recognition that there will be some exceptions; it's not an excuse for large design holes.
"Architecturally complete" means that all public XPIDL interfaces have been reviewed for correctness, completeness and aesthetics; and have then been blessed by mozilla.org.
Well yeah sure. I wish their interface defaulted to a less color oriented theme. Wish that fonts were more happening and consistent with the other browsers as well.
3. Acceptance: There's a consensus in the Mozilla community that M12 is usable. Ideally, a majority of M12 users will try to live in Mozilla as their primary browser and mail program, ane restart it when it crashes. We don't want to set an unrealistic goal just yet, but we will measure and poll after M12 is out, in order to decide whether it was in fact "usable".
Sure.
Call it alpha! Pitch in, people, the lizard is getting close!
It's easy enough to gauge. If you sit someone that's not installed it before in front of a terminal, and if he can get it up & running in five minutes....and keep it running in "average" use for an hour. Then the install script works, the READMEs are there to get it running, and it doesn't crash if you fart at it. That's Alpha.
I always assumed Alpha to be your development versions, and the last couple of versions before release are Beta.
Beta is the stage where you have stopped adding features and are just working on clobbering bugs.
Typically, an "Alpha" version is feature-complete (as far as the developers know), and is ready to be used in non-critical ways within the company where it was developed. Features can still be added during Alpha testing, but only if several of the testers and developers agree that they are really necessary. It's okay if there are bugs and crashes, as long as the product is mostly useable.
I'd say the last Mozilla release was pretty much there.
It'll have developed large areas of silver hair on its back, amass several females in a personal harem, and keep the others in line with displays of violence and aggression, sometimes ritual and sometimes real.
Oh, I'm sorry. I thought the question was about what happens when Mozilla becomes an alpha male.
"If one is really a superior person, the fact is likely to leak out without too much assistance" -- John Andrew Holmes
This is the way my shop does alpha/beta conditions.
First, you have pre alpha state of software. Pre alpha testing include basic system stability, individual feature testing, and system testing, where each feature, as well as the whole system, are put through basic tests that would be considered "normal operating conditions".
After this testing is passed, alpha state is declared.
Then beta testing involves major tests that test the limits of the system; a lot of non-standard situations that the software should not have to encounter (but will, for any number of reasons).
If beta level is reached, then we released the software to our clients; and the rest of the bugs that slipped through the cracks are patched.
This clear?
"Don't mind me cutting myself on Occam's Razor"
Wha?!?!?! an hour?! . .
Now please allow me to preface my comments with where my point of view comes from. I work in the machine tool industry, where MTBF is measured in thousands of hours.
Am I just off base? or is this criteria horibly inatiquit. Even for an Alpha.
Intended functionality exists, with no known bugs. Alpha allows the developer to test for platform and user compatibility. This is where users break the beastie.
For instance, apps for v1.0 and earlier releases of KDE were typically alpha. Although considered alpha, they were quite stable.
Graham
Graham
Linux - Fast Pane Relief
That criterion and phenomenon, or bacterium and millennium, shall someday undergo more complete assimilation is far more likely a question of "when" than it is of "whether". As this occurs, strange corruptions like double plurals sometimes arise and occasionally persist, such as the "these bacteriae" example I read and recoiled from the other day. What's next, "millennias"? :-(
All you really have to go on is your ear, but checking the OED never hurt anybody. :-) And at this time, "criteria is" seems just jolting an error in numeric concordance as "pathos are". Yes, Greek sucks in its complexity. And English is annoying in its unpredictable assimilation strategies. But you really aren't going to change either. That's just how it is.
To make this posting useful and geek-relevant, you might check out Perl's Lingua::EN::In flect module. It's filled with boatloads of examples of these.
ObFunny: How many Germen [sic] does it take to change a language? :-)
Alpha = feature freeze. All planned features are in and working as advertised for typical use.
Beta = code freeze. All planned features are working for typical and atypical use, as far as testing can determine. Testing has run coverage tests, and can't find any crashes or surprises. A cautious release could be made, with a "we think it's good, but what do we know about you crazy people" label firmly attached.
Release = No show stopper bug reports have come in in several days or weeks. All other bugs are trivial or border cases, though if time and market permits, you'd like to nail them too.
Stable = It's been in production use for 2 times the typical use time* and no one has complained.
*Typical use time varies as the the product. For a game like Quake, I'd say this is at least two nights of serious muliplayer gaming, plus a couple of weeks for people to do a full feature discovery. For something like Linux kernel, it's several months of production use. For a CAD/CAM program, it's a few real projects from start to completion.
Pin the spig.
As such, Mozilla is Alpha Level software right now. I think that Mozilla should STAY at the Alpha level as long as possible because that is where the software develops rapidly like a baby in the womb. After the features freeze, so to speak, then the final testing phase (Beta) should begin. Iron out all the little bugs and make it stable as can be. Then release it to a grateful world.
The worst thing that could be done is to release a premature and buggy product - that would kill it surer than if Microsoft bought AOL.
Codifex Maximus ~ In search of... a shorter sig.
The reason they shouldn't release deltas is that it's the next letter after gamma, which comes after beta, which comes after alpha. By the time you hit delta, users of begging for production releases. They call you up and say "WHERE IS OUR SOFTWARE?" I don't think they like hearing that you're within epsilon of shipping, either. :-)
From TNHD:
Personally, even before I read this, I went with the definition described by the B-Test. For me, this means the first version of the software that functions according to the original specifications...or the first version that is basically functional. Its hard to say where to draw the line with the Bazaar-style of development, since this line could be drawn at many points in the development process.
In my experience, where this line is drawn is often more political than technical, especially if money is involved.
My journal has hot
A release candidate is when all the code is finished and all known bugs are gone. It's another round in the testing cycle to catch a few minor bugs that probably appear on only a few configurations. A release candidate may become the finished product if no fixable bugs are found (which is why it's called a release candidate).
:-)
But for Microsoft products, release candidate == pre-alpha.
Well, their phrasing is wrong even if you discount their error in forming plurals. Since they have a set of criteria, not just one criterion, "a criteria" is incorrect any way you look at it. "A criterion," while grammatically correct, would still be wrong, unless they really only have one criterion. Correct ways of phrasing it would include "some criteria" or "a set of criteria."
10 PRINT CHR$(205.5+RND(1)); : GOTO 10
hmm, well i don't speak ancient Greek, but modern Greek has no dual number for verbs. There's just a singular and a plural number.
10 PRINT CHR$(205.5+RND(1)); : GOTO 10
I've always taken it to mean that an Alpha is the first version that does 95% of what it has to do and is stable enough to send to an internal tester without a programmer standing behind them telling them not to click on certain things.
And a beta would be when it's stable enough to send out for user comments, not be necessarily stable enough for them to consider using regularly.
I'd call Mozilla a late Alpha, or early Beta now.
The terms have gotten twisted in the last few years, mainly in my opinion, by Microsoft. MS has had OSes at a nearly-ready stage for years, and uses Beta to mean, it's done, but if it crashes, that's cause it was a Beta.
To me, a beta is something you don't run on anything mission critical. I wouldn't use a truly Beta OS on even my PC.
So, I think Mozilla is in Beta now, or would be if the terms hadn't changed to justify clumsy bloatware.
- Pre-alpha: Partial features. Still under serious development.
- Alpha: All major features work most of the time. May be missing some chunks, and/or may not work under some circumstances. May not cooperate nicely with other programs. Beware memory leaks, non-standard configurations, etc.
- Beta: All major and most minor features work. Some bugs under particular configurations. Some "we don't know why" bugs still being ironed out. Developers are looking for configurations / situations where stuff blows up.
- Release: All features work, except perhaps in uncommon configurations. Bugs (hopefully) are minor.
This, of course, is in an ideal world==================================
neophase
==================================
neophase
Speaking of Greek, traditionally "alpha" was the designation applied to something that's little past the prototype stage, and sometimes, is nothing more than that. It doesn't refer to the propensity for bugginess, but rather to whether the interface is decided or not. And in the case of alpha, it's not. The interface can change completely in later stages. Parts may be missing. Parts may be added.
In beta, on the other hand, we're done with that. Beta is the stage after which functional changes are forbidden. You can't change the interface in the jump to production. Everything must behave as documented to behave. All you can do is fix bugs. No new features. No change in calling conventions.
I have actually seen "gamma" releases, too. This seems to mean "We hope to God this is production calibre."
After beta--or rarely, after gamma--comes production. Never issue deltas, except in the form of a patch. :-)
When you start community-building, what you need to be able to present is a plausible promise. Your program doesn't have to work particularly well. It can be crude, buggy, incomplete, and poorly documented. What it must not fail to do is (a) run, and (b) convince potential co-developers that it can be evolved into something really neat in the foreseeable future.
Question: Does this mean that projects going open-source should be Alpha stage before recruitment begins? If not, then what stage would you call it when your project is ready for open-source?
Disclaimer: I am a /. newbie, so point me in the right direction if this question has already been asked...
Make sure everyone's vote counts: Verified Voting
Can you elaborate a little on how I will be able to "use the engine" for my own browser. Is this something like an API or libraries that I can call from a c program? I'm just a little fuzzy here.
Stay in alpha as long as possible?
I'm afraid that you'll have to justify that claim to me a bit. As I see it, early releases grab attention, buggy or not.
This may be the psychological irony: tiny frustrations and aggravations, coupled with the promises of better things to come, *engage* the consumer with the product in a way that promotes it. A seamless, flawless experience is - dare I say it? - forgetable. If you make it look too easy, people will think that it is.
Aside from the obvious example (Microsoft), I can think of a couple other products that fit this pattern, including Gnome.
Now, I definitely don't think this is a good thing (I don't believe that humans are essentially rational, and the people who act on that basis - i.e., the advertising and marketing industries - seem to be thriving quite nicely), and I would like to be proven wrong. Can you name any historical product releases that showed how patient attention to detail is rewarded in the mass market?
On the issue of punk-ass posers trying to act like Alpha males ,I thought ya'll might like to see this photo I made for AlBore2000.com
Seems to me that the Linux model of devel tree and stable tree is much more appropriate. When Mozilla is ready to start a stable branch (and it's getting fairly close), then I think that's what they should do.
Leave the "alphas" and "betas" to the Netscape Communicator crew.
Interested in XFMail? New XFMail home page.