I want a new release!!!

[titi_son]

I think its very long time since the last release and i know its hard to make the svn-version playable.
But this have to start ones and i think its time. What about a beta (or alpha) to test?
If you agree me vote "YES  " please

If a new release would come up a new Annex release will be there too. (that told Ishmaru me,I don't know if its right)

[ElimiNator]

Why don't you just ask your dad?

[victorj]

I do not think so because as more delay we a better version and more features packed but I admit It is difficult to wait. 

[MuwuM]

Why don't you just ask your dad?

Because he want a release for everyone. And not a custom build for himself.

I do not think so because as more delay we a better version and more features packed but I admit It is difficult to wait. 

Guidelines for creating good open source software (source wikipedia)

7. Release early. Release often. And listen to your customers.

show original

Early and frequent releases are a critical part of the Linux development model. Most developers (including me) used to believe this was bad policy for larger than trivial projects, because early versions are almost by definition buggy versions and you don't want to wear out the patience of your users.

This belief reinforced the general commitment to a cathedral-building style of development. If the overriding objective was for users to see as few bugs as possible, why then you'd only release a version every six months (or less often), and work like a dog on debugging between releases. The Emacs C core was developed this way. The Lisp library, in effect, was not—because there were active Lisp archives outside the FSF's control, where you could go to find new and development code versions independently of Emacs's release cycle [QR].

The most important of these, the Ohio State Emacs Lisp archive, anticipated the spirit and many of the features of today's big Linux archives. But few of us really thought very hard about what we were doing, or about what the very existence of that archive suggested about problems in the FSF's cathedral-building development model. I made one serious attempt around 1992 to get a lot of the Ohio code formally merged into the official Emacs Lisp library. I ran into political trouble and was largely unsuccessful.

But by a year later, as Linux became widely visible, it was clear that something different and much healthier was going on there. Linus's open development policy was the very opposite of cathedral-building. Linux's Internet archives were burgeoning, multiple distributions were being floated. And all of this was driven by an unheard-of frequency of core system releases.

Linus was treating his users as co-developers in the most effective possible way:

7. Release early. Release often. And listen to your customers.

Linus's innovation wasn't so much in doing quick-turnaround releases incorporating lots of user feedback (something like this had been Unix-world tradition for a long time), but in scaling it up to a level of intensity that matched the complexity of what he was developing. In those early times (around 1991) it wasn't unknown for him to release a new kernel more than once a day! Because he cultivated his base of co-developers and leveraged the Internet for collaboration harder than anyone else, this worked.

But how did it work? And was it something I could duplicate, or did it rely on some unique genius of Linus Torvalds?

I didn't think so. Granted, Linus is a damn fine hacker. How many of us could engineer an entire production-quality operating system kernel from scratch? But Linux didn't represent any awesome conceptual leap forward. Linus is not (or at least, not yet) an innovative genius of design in the way that, say, Richard Stallman or James Gosling (of NeWS and Java) are. Rather, Linus seems to me to be a genius of engineering and implementation, with a sixth sense for avoiding bugs and development dead-ends and a true knack for finding the minimum-effort path from point A to point B. Indeed, the whole design of Linux breathes this quality and mirrors Linus's essentially conservative and simplifying design approach.

So, if rapid releases and leveraging the Internet medium to the hilt were not accidents but integral parts of Linus's engineering-genius insight into the minimum-effort path, what was he maximizing? What was he cranking out of the machinery?

Put that way, the question answers itself. Linus was keeping his hacker/users constantly stimulated and rewarded—stimulated by the prospect of having an ego-satisfying piece of the action, rewarded by the sight of constant (even daily) improvement in their work.

Linus was directly aiming to maximize the number of person-hours thrown at debugging and development, even at the possible cost of instability in the code and user-base burnout if any serious bug proved intractable. Linus was behaving as though he believed something like this:

8. Given a large enough beta-tester and co-developer base, almost every problem will be characterized quickly and the fix obvious to someone.

Or, less formally, ``Given enough eyeballs, all bugs are shallow.'' I dub this: ``Linus's Law''.

My original formulation was that every problem ``will be transparent to somebody''. Linus demurred that the person who understands and fixes the problem is not necessarily or even usually the person who first characterizes it. ``Somebody finds the problem,'' he says, ``and somebody else understands it. And I'll go on record as saying that finding it is the bigger challenge.'' That correction is important; we'll see how in the next section, when we examine the practice of debugging in more detail. But the key point is that both parts of the process (finding and fixing) tend to happen rapidly.

In Linus's Law, I think, lies the core difference underlying the cathedral-builder and bazaar styles. In the cathedral-builder view of programming, bugs and development problems are tricky, insidious, deep phenomena. It takes months of scrutiny by a dedicated few to develop confidence that you've winkled them all out. Thus the long release intervals, and the inevitable disappointment when long-awaited releases are not perfect.

In the bazaar view, on the other hand, you assume that bugs are generally shallow phenomena—or, at least, that they turn shallow pretty quickly when exposed to a thousand eager co-developers pounding on every single new release. Accordingly you release often in order to get more corrections, and as a beneficial side effect you have less to lose if an occasional botch gets out the door.

And that's it. That's enough. If ``Linus's Law'' is false, then any system as complex as the Linux kernel, being hacked over by as many hands as the that kernel was, should at some point have collapsed under the weight of unforseen bad interactions and undiscovered ``deep'' bugs. If it's true, on the other hand, it is sufficient to explain Linux's relative lack of bugginess and its continuous uptimes spanning months or even years.

Maybe it shouldn't have been such a surprise, at that. Sociologists years ago discovered that the averaged opinion of a mass of equally expert (or equally ignorant) observers is quite a bit more reliable a predictor than the opinion of a single randomly-chosen one of the observers. They called this the Delphi effect. It appears that what Linus has shown is that this applies even to debugging an operating system—that the Delphi effect can tame development complexity even at the complexity level of an OS kernel. [CV]

One special feature of the Linux situation that clearly helps along the Delphi effect is the fact that the contributors for any given project are self-selected. An early respondent pointed out that contributions are received not from a random sample, but from people who are interested enough to use the software, learn about how it works, attempt to find solutions to problems they encounter, and actually produce an apparently reasonable fix. Anyone who passes all these filters is highly likely to have something useful to contribute.

Linus's Law can be rephrased as ``Debugging is parallelizable''. Although debugging requires debuggers to communicate with some coordinating developer, it doesn't require significant coordination between debuggers. Thus it doesn't fall prey to the same quadratic complexity and management costs that make adding developers problematic.

In practice, the theoretical loss of efficiency due to duplication of work by debuggers almost never seems to be an issue in the Linux world. One effect of a ``release early and often'' policy is to minimize such duplication by propagating fed-back fixes quickly [JH].

Brooks (the author of The Mythical Man-Month) even made an off-hand observation related to this: ``The total cost of maintaining a widely used program is typically 40 percent or more of the cost of developing it. Surprisingly this cost is strongly affected by the number of users. More users find more bugs.'' [emphasis added].

More users find more bugs because adding more users adds more different ways of stressing the program. This effect is amplified when the users are co-developers. Each one approaches the task of bug characterization with a slightly different perceptual set and analytical toolkit, a different angle on the problem. The ``Delphi effect'' seems to work precisely because of this variation. In the specific context of debugging, the variation also tends to reduce duplication of effort.

So adding more beta-testers may not reduce the complexity of the current ``deepest'' bug from the developer's point of view, but it increases the probability that someone's toolkit will be matched to the problem in such a way that the bug is shallow to that person.

Linus coppers his bets, too. In case there are serious bugs, Linux kernel version are numbered in such a way that potential users can make a choice either to run the last version designated ``stable'' or to ride the cutting edge and risk bugs in order to get new features. This tactic is not yet systematically imitated by most Linux hackers, but perhaps it should be; the fact that either choice is available makes both more attractive. [HBS]

[ElimiNator]

Why don't you just ask your dad?

Because he want a release for everyone. And not a custom build for himself.

No, I mean he can ask his dad to get a release for everyone.

[Ishmaru]

From what I understand, next version is a MAJOR update, so I'm sure many things will have or will need to be re-coded to work properly which takes a lot of time plus each of these things must be retested as many bugs will show up with all the changes. Tomreyn has been nice enough to post svn builds for windows (and linux?) every couple weeks for those who don't compile on their own. You could find latest one here: https://forum.megaglest.org/index.php?topic=8426.msg83028#msg83028

As for Annex, yes I am waiting for next MG release, but Annex isn't ready for a release either, so no rush necessary. I personally prefer to want to have a good solid stable release of Megaglest to base Annex off of. If push comes to shove I could always use 3.6.0.3.
 

[Coldfusionstorm]

its out "soon" TM

[softcoder]

Step #1, test the svn builds and post your findings (bugs found and level of stability). Also we still need better images for the cell marker feature and possibly changes to make it look the way described in the other thread. I have fixed many bugs in recent weeks, and not all have been tested by those who reported them.

[titi_son]

Why don't you just ask your dad?

Because he want a release for everyone. And not a custom build for himself.

No, I mean he can ask his dad to get a release for everyone.

He don't want a new release because he thinks we could lost online-players.

[tomreyn]

Just to prevent misunderstandings due to the parody I posted: I would also be happy with a new release. I don't think it's urgent, but it would be nice to have. On the other hand I have not, although planning to, tried to dig deeper into learning how to release myself, so hat's one reason I can hardly push for it (since I cannot directly contribute). For now I'll continue to contribute indirectly by means of testing, bug reporting, and testing again (to verify fixes work on my end, too).

Eric S. Raymond (whose fully quoted text, in my experience, every programmer knows) is surely not wrong about releasing early and often, and if you look more closely this has been the MegaGlest approach all along. This time it's taking a little longer than usually, it's now 5 months since the last release, but this is still pretty good compared to other open source and hobby projects, and we've also seen two releases in just one month before. And as Softcoder already pointed out: everyones' contributions can help speed it up.

[MuwuM]

Maybe we should do some kind of nightly builds, for the one's that don't want to complie anything, but would like to test. (I know that it would mean even more work)

[Omega]

Maybe we should do some kind of nightly builds, for the one's that don't want to complie anything, but would like to test. (I know that it would mean even more work)

Compiling is reasonably easy though. At the very least, it's as straightforward as running some basic instructions word for word. MegaGlest automates a lot of it. I just don't know if it's worthwhile for the time it takes. If someone can't compile it themselves, can they necessarily do bug reports and such properly? Plus, Tom releases occasional windows builds for those who are completely beyond compiling themselves.

[victorj]

We are with an absurd number of players compared to before, I do not think we need a new release now, I think we could wait awhile longer for a new version, if we release now will lose some players. 

[Bloodwurm]

True that new buggy releases can make your game lose players. At the same time, more players means more testing. More testing means more bug fixes, which means more stability and thus higher quality.

Also, I would argue that by having less releases, you end up loosing players. People that search the net for these types of games don't look for games they can compile themselves. They want to DL, install and play.
And then they probably want to mod and create! They dont want to get into the hassle of compiling if the only thing they want to do is tweak some xml.
Some might be inclined to wait for the next release for their awaited feature but some just won't and will quit or move on (or get fed up when they see the next release is not coming).

Take GAE for instance, I can easily find only two download links, one for GAE 0.3.2 (which dates back to end of oct. 2010) and GAE 0.4 Beta 1 (which dates back to april 2011). Both are rather old. If someone is still waiting on some feature, and doesn't want to start compiling 'cause say they are nowhere near familiar with coding, well...
A year is a long time to wait for a feature.

Releasing buggy software is a reality of software development, you just can't catch them all. How many testers do you think Blizzard/EA/Activision/Other have to test out their games? An army. And they still are able to release buggy piece of s***. Preventing a release for an open source community is just adding a nail to the project's coffin imo. Let the community test it, sure you'll discourage some, but if you have a good presence on the board, and fix those crashes/bugs fast, you should still be able to grow your player pool.

The only thing I would say about daily builds is that it would probably eat up Hardware space quite quickly (sure you can delete old ones but its always a pain, keeps coming back at you with a hunger for flesh.... arrgghh!). I would suggest monthly builds or something.

My 2 cents.

[softcoder]

I personally won't consider releasing any sooner than we currently do until I see a greater effort in at least the basic area of testing. RTS's that do network play are quite different from most games because of the common issue of out of synch problems. The more people that add their opinion to these kinds of threads, the more I will re-enforce my comments about the need for others to contribute to the release itself. At this point there are very few who actual do that. The release cycle happens as quickly as people 'make' it happen , its as simple as that.