Using Agile Methodologies To Make Games? 236
simoniker writes "Using Agile methodologies for programming is a concept that's been around for a while now, but some firms are now applying the concept to video game development." There has been a lot of talk lately about what the 'next big thing' in development will be. Could this be it? Or is this just another step along the way? From the article: "Agile puts the emphasis on producing demonstrable iterations of a game almost immediately into production, creating prioritized vertical slices that iterate on the most critical elements and features. The method also puts great emphasis on the organization of teams and the relationships therein, as well as the cycles in which teams must plan and carry out their project objectives."
The Bane of My Existence (Score:5, Insightful)
And so started a cycle of hatred towards methodologies about how to be productive in application development.
To me, the wild wild web is still here. I still get my kicks from coding without set in stone documentation and I still hate schedules.
I've always had the view that every project was a wild animal. Worse yet, it's a wild animal in sheep's clothing. And you approach the sheep with a shepherd's hook. When the veil is lifted and you see man eating marsupial with alligator teeth and a scorpion's tail, you have no choice but to throw the shepherd's hook at them and give it all you've got.
And this is how I approach managing a development project. You remember prior projects and throw together a bag of tools that have worked before and then you set to taming the beast. If you tell yourself "Waterfall works every time" then you're just going to find yourself with a shepherd's hook facing a lion or a bear.
Instead, you learn to adapt to every situation and that's the important thing. The rules are few and loose. The customer has the power to destroy everything and you have to deal with it. The best development is done on the fly with just enough documentation to convey the big idea of what's going on and keep everyone on that page. Given real life schedules and timed deadlines, there is such a thing as too much documentation.
Agile development is better in that it allows you more play and doesn't inhibit spur of the moment innovation. I think some of my most demoralizing moments have been when I realized some great new possibility for a project only to have my manager tell me that so much documentation would have to change that "maybe we'll put that in next year's scope." I find this to be ridiculous.
What was happening was people were starting to assume that waterfall was the silver bullet for project management. "What kind of project is it?" "I don't care, we're using the waterfall." And the big problem is that the waterfall is only considered 'adaptable' if you're ok with reworking everything from step one. Is this really necessary for every project though?
Another new thing we have these days is a "framework" that fits a specific type of problem well. You can throw these together on the fly and have very little documentation because the framework provides a well known implementation strategy (see Spring's MVC).
It is my opinion that using an incremental deliverable approach with frequent customer meetings and executive power at any point in the project is the most successful strategy. The "rules" you have to adhere to are up to you and should be purely a case by case basis.
Why do we constantly look for the "next big thing" when the "big thing" is simply experience?
Most aggravating (Score:4, Insightful)
I like this
The next big thing? (Score:5, Insightful)
I doubt it. Smart dev teams have been using iterative development cycles and keeping their code tidy since a long time before anyone coined the buzzphrase "agile" (or using SillyCapitalLetters and calling things "extreme", or any of the other hype we've put up with lately).
Buzzwords aplenty (Score:4, Insightful)
Can someone tell me what this means?
Sounds like a formula for spaghetti-ware (Score:3, Insightful)
An iterative approach where you use a greedy method of implementing each new feature as quickly as possible with little insight into the overall system may or may not produce optimal results. It can lead to lots of spaghetti code. Or maybe not. Certainly in my career that approach sometimes *has* led to cleverer solutions as I was forced to think up the best, simplest way to imlement them. But often it can lead to massive amounts of spaghetti code that doesn't make much sense or capture any insights into the problem.
Programming Methodologies Are Dangerous (Score:5, Insightful)
The guy who suggested it, "It's an itterative development model. We identify core features, develop those features, refine those features with the customer, then add the next layer, repeating as we go. We gain much better code as every component meets the customer's need as it is developed, challenging the customer to think about it in context, and allowing us to add additional itterations if needed."
Management, "So, we can identify additional features throughout development?"
"Absolutely. You just have to assign additional resources (time/people) to account for those extra features. But, by identifying them as they come up, you end up with a much better system that really does everything right."
Over the next few months, features kept getting added, developers dutifully updated schedules. All was happy. Followed by...
Management, "This was supposed to ship before thanksgiving. It's now slated to ship in the new year. We'll entirely miss the holiday season."
Rapidly realizing his mistake for suggesting it guy, "Yes. But you kept coming up with new features. And they are great new features. Think how much better the product is for it."
"If we miss the holiday season market, we lose money. This has to ship 'on time'."
"But on time is a function of how much you add. We're developing everything to schedule. You've just increased the features so increased the schedule."
"The schedule can't move."
"So you'll have to lose some of the remaining itteration milestones. You'll have to drop features."
"But we like all the features we've come up with."
"But adding features adds time. You've known that since the beginning."
"We've known this has to ship for the holiday season and you promised us we could have extra features. You're just going to have to work more overtime. Fortunately you're overtime exempt so that won't cost us anything to get this project back on schedule."
"It is on schedule. You just changed the schedule by adding features that were identified along the way."
"You told us your wonderful "XP" model would let us do that. We gave you the chance to try this new method under the understanding we got these benefits."
"And you do."
"Good. Then make your schedule."
"We are mak-"
"No arguments. This discussion is over. You promised you could deliver the extra features. You're now behind schedule for the holiday season. You're just going to have to crunch. End of discussion."
Yeah, thanks XP.
Never, ever, raise exciting new methodologies to management. They will hear all of the advantages and expect every last one of them as though it was the perfect implementation of the method whilst completely failing to hear (and certainly refusing to act on or implement if they do hear) any of the trade-offs that have to be made to enable those gains.
Re:The Bane of My Existence (Score:5, Insightful)
I, too, was taught about software engineering processes during my CompSci days. But in my case, the waterfall model was the textbook example of how not to do things...
Of course, you can take things too far that other way as well. Being too rough and ready -- something encouraged by an "agile" approach -- may get you best results locally, but what matters is getting optimal results globally across the lifetime of the project and all its features. Just as the old hands look at managers trying in vain to match reality to a waterfall model and smile, so they look at young enthusiasts diving in with little to no big picture planning and wait for things to fall apart.
Re:The Bane of My Existence (Score:5, Insightful)
Because managers don't trust engineers.
They don't understand what's going on, and yet they have to manage it.
So they hear about a new methodology, drink it up like a common sucker drinks up Scientology, and turn it into a religion.
Everything you don't understand you fear, and then you turn it into a religion.
All too common behaviour, all throughout our history.
If they tried to understand it all instad, they probably wouldn't be managers; they'd be engineers.
Most people don't care about how things work; they only want them to work and to work always.
Magic-minded lot, all of them.
Way too much market speak... (Score:5, Insightful)
In order to energize the evolution of computer games we need to synergize on the vertical slies... WTF?
I guess people forgot to mention that writing computer games rates up there with writing operating systems in complexity...
30 day sprints? (Score:3, Insightful)
I love iterative development, but scrum didn't impress me much when I was involved with it. Perhaps that was just due to the management that implemented it. We went from logging bugs and tasks in bugzilla to writing them on index cards (do I really need to point out to computer people how stupid that is?), and trying to plan projects on these obscure, poorly implemented planning tools.
Iterative development is great, but scrum strikes me as nothing more than another useless management fad.
Managers <sigh> (Score:5, Insightful)
This is just an issue with management, though. A good manager will trust his engineers (or fire them and replace them with trustworthy alternatives). The manager's job is to set the direction of the project, get the engineers what they need to steer in that direction, and then get out of the way as much as possible and as quickly as possible.
It's staggering how many managers don't realise this, and hamstring their dev teams with their personal, half-baked, technically-incompetent ideas and/or with excessive procedures and beaucratic reporting because the manager "has to know what's going on". Of course he does, up to a point, but what exactly is he going to do if a developer does tell him that a bug fix was delayed by a day because {$TECHNOBABBLE}? If he's not going to act on some information, he doesn't need to know it, and requiring developers to take time out of their day to "keep the manager in the loop" more than necessary just disrupts development.
Re:The Bane of My Existence (Score:2, Insightful)
You're right. And there's another reason, because many engineers have tunnel vision and cannot grasp that each project has dimensions involving a) the customer, b) money, c) limited time, d) getting it done now instead of wanking around building the Worlds Most Beautiful Piece of Software.
Every system is broken. Some systems are less broken than others. A new system always has a promise of the better, until we've used it and know for sure.
Take it from me ... (Score:5, Insightful)
Re:Programming Methodologies Are Dangerous (Score:3, Insightful)
Re:The Bane of My Existence (Score:3, Insightful)
You can have it done cheap, fast or well.
Managers mostly want cheap and fast. Engineers want well.
And generally, you can only have one of the three.
Re:Programming Methodologies Are Dangerous (Score:4, Insightful)
If someone is paying you to write software then "Earning out paychecks" or "keeping on budget" must be a critical feature. We may like to think otherwise, but companies don't pay you because they love you. They pay you because you earn more money for them then you cost. If it was the other way around, your paycheck would bounce and/or layoffs would ensue.
Re:Sounds like a formula for spaghetti-ware (Score:1, Insightful)
I have given up on trying to completely model the "application domain" from the project outset since requirements invariably change over time. Instead, the goal should be to create a flexible, maintainable and extensible application design. This is the core of agile development and in my mine is the only way to go, regardless of the language.
Re:Buzzwords aplenty (Score:4, Insightful)
1. You start with an extremely barebones (read: you'd never release this into the wild) program that actually runs, passes all its unit tests, and implements maybe one important feature. (eg: a shopping cart program which will show you the contents of a catalog.)
2. With each iteration, you add a new feature, refactoring older code as necessary. Start with critical functionality and work your way down the requirements.
3. Continue until the product is releaseable.
The "vertical" bit means that rather than taking the "let's implement all the methods we'll need in the CatalogItem class first" approach (horizontal), you're trying to make it actually do something useful (eg, show a list of products) with each iteration.
Product development (Score:5, Insightful)
You see, the closest you have for a user of a new game is a gamer and those can't really help you refine your requirements 'cause all they want from a game is to be entertained and they don't really know beforehand how a new, entertaining, game will look like - "having fun" is hardly an easy to define business process.
Maybe some sort of mixed approach where you have a game designer with an overall view of the game concept and a generic pool of gamers to check out the "fun factor" during game development. Might work well for games with an "exploration" component (for example RPGs) for which you can design the early levels, "test" them with some gamers and then use the result to fine tune those levels and later ones. Still, i doubt it can be usefull in game genres such as RTS and Sims.
More in general, and judging from the posts i've been seing in
Re:Sounds like a formula for spaghetti-ware (Score:2, Insightful)
It only sounds like that if you skip the important parts.
Agile methods are not about skipping requirements, or modeling, nor about coding in a casual or non-deliberate way.
Agile methods are about recognizing that requirements are a moving target, That the more you implement your solution, the better you will understand the model, and possible problems with your model of the problem domain, and that the best program on earth is worthless if it doesn't work for the end users.
So, there's a large collection of techniques that most programming veterans (OO or otherwise) utilize to help get things up and running without having to send anyone "over the waterfall."
Check out Dave Thomas and Andy Hunt [pragmaticprogrammer.com], Martin Fowler [martinfowler.com]or the Portland Pattern Repository [c2.com] for a good starting point.
Re:Programming Methodologies Are Dangerous (Score:3, Insightful)
Re:Sounds like a formula for spaghetti-ware (Score:4, Insightful)
Two counterpoints:
Re:Sounds like a formula for spaghetti-ware (Score:4, Insightful)
...who, by definition, will produce good results using pretty much any methodology. The test of any business process is how much it helps the guys who aren't already good, not how much it helps the office guru.
Re:Take it from me ... (Score:3, Insightful)
Interviews are great--as long as they get at standard information. Otherwise you end up asking applicant a one thing and applicant b another and then you have no clear way to determine which is better. Under this method you end up with 'good enough', rather than 'the best we can find at our budget', which is not really the same thing at all.
If you want more information on hiring good people drop me an email or go talk to a professional.
Re:Managers (Score:3, Insightful)
Which can never be done reliably for non-trivial projects with the tools and techniques we have available today, regardless of what anyone trying to sell you their book says. No-one has yet shown how to beat picking two of cheap, fast and good.
Which is a much higher level than the sort of day-to-day project stuff we're talking about here.
It doesn't, in this context. Again, no executive of a large company should routinely be involved in the day-to-day progress of minor projects by a particular dev team. That's not their job, and it's the worst kind of micromanagement.
It also means you need metrics worth something, which random estimates for project timescales based on the inadequate information that was available six months earlier most certainly are not.
A pipedream (Score:3, Insightful)
This reminds me of something I just read about how episodic content will never work, as making episode 1 requires 95% of the work of the entire game.
Show me the money! (Score:3, Insightful)
Re:Programming Methodologies Are Dangerous (Score:3, Insightful)
This is nothing new even in pro game development (Score:3, Insightful)
We use nightly builds (a single day without a working build is a huge hit). Getting the framework working so your designers and texturers (and gameplay folks) can start trying stuff in-engine, then fleshing out features. Midding sized time periods (2-4 weeks) between major builds. Unit testing. Though we have to bring in humans to really break it when it's all put together.
Now if you mean Agile with a capital A, then it's not the next big thing, it's just the same bullcrap it was when it was called eXXXtreme Programming. We like to write things down and design a lot of things up front, which clashes with Agile (and don't tell me it doesn't, even with the lip service) - you need at the very least a production bible for large project games to keep everyone together. Parts of the design will sometimes not survive actual implementation and will be tossed, but in general they keep things on track and usually only need some tweaking (everything gets tweaked during playtest time).
If you don't do this sort of thing you end up with http://en.wikipedia.org/wiki/Dungeon_Lords [wikipedia.org], which is what you get with a Agilely (with a capital A) developed game. It shipped only half complete with no internal cohesion at all and still isn't finished. But the great thing is that you can use your Methodology to justify it all.
RUP (Score:3, Insightful)
As a project lead, I like RUP.
It has aspects of Agile to it.
The important parts are:
Get the risky stuff addressed early. If DX9 doesn't support bi-pixar multi-shading like it says it does, then it is best to find out early rather than at the end.
Do the work in measurable chunks. That way you know in as little as a month if you are falling behind schedule.
Frequently interact with the users to make sure you are on course. This is the biggest problem with waterfall projects- working 6 months on something and it turns out you made a wrong turn on week 2. And I've seen other programmers do this again and again even with user interaction- they get an idea of what the program should be like in their head and turn off input from reality.
All the documents and crap bother me to and feel like useless makework. At least video game programmers do not have to deal with SOX compliance issues.
Re:Software Engineering stiff, meet Game Developer (Score:2, Insightful)
Re:Buzzwords aplenty (Score:4, Insightful)
I guess it's because I work on software where the tolerance for bugs is a lot less than it is (apparently) in desktop PC software, but I have a hard time seeing one of these methodologies producing clean code.
If your application is going to get shipped and then never looked at again, I guess "clean code" might not matter, but if you're building an enterprise system, or writing a custom application that has to be maintained by other people later (people who probably aren't going to be quite so much of an 1337 h4x0r as you), it's a must.
Documentation and specifications aren't just something that you do in order to satisfy the PHBs of the world; they serve a real function. A system that's been well-specified to begin with is much easier to fix later, at least in my experience, than one that's been produced during a death march and is nothing but a giant rat's nest of code.
I could see the benefit of an "agile" development cycle for prototyping or producing a quick demo, but the idea of critical pieces of software -- software that your customers are going to depend on and that other people, months, years, or decades down the line are going to have to maintain and update -- being built this way scares me a little.
Listening to programmers bitch about documentation is like listening to a bunch of carpenters bitch about architectural plans. Of course you could get the house built a lot faster if you just took 15 builders and said "hey you, build a wall here!" and "you, build a bathroom over there!"
Re:Programming Methodologies Are Dangerous (Score:2, Insightful)
Re:Take it from me ... (Score:3, Insightful)
This may be true, but the software industry doesn't work that way. Managers want people to be interchangable parts, because that way they can easily replace them when they leave. So they focus on methodology.
Ironically there is one process that I believe is critical to every organization's success, and it probably the least-studied, least-optimized, least-formalized process every company has
This is probably directly related. The managers and HR droids apply their standard interview process, effectively hire people at random, and conclude that they can't reliably get good people - hence the above.
One of the big problems I see is that the interview process is normally optimised to hire the best salesdroid in the group (because they're best at "selling theirself") regardless of whether they are hiring for a sales role or not. Good engineers are cautious and precisionist in their speech, so they tend to "perform worse" at interviews by giving more precise, less optimistic answers.
Re:The Bane of My Existence (Score:3, Insightful)
They're not mutually exclusive. Instead, think of them as the corners of a triangle. You call them "cheap," "fast," and "well" (because it makes better sense gramatically) but call them "cost," "speed," and "quality" respectively.
The general, and arguable, assumption is that customers are tied to cost, managers are tied to speed, and developers to quality. Usually the trouble comes from the priorty of each group. Customers tend to lean towards cost, speed, and quality. Managers tend towards speed, quality, and cost. Developers tend to go for quality, speed, cost.
This also aligns with the two-sided client-vendor cost equation; customers want to pay less and vendors want to make more.
Most people act as though they can only choose points only along the sides of the triangles, but this isn't really true. Sometimes it's just harder to recognize compromise to the gradients in the middle of the triangle. With this model, if you're on the line between "cost" and "speed", it appears as though you've completely sacrificed "quality."
In reality you pick from anywhere inside the triangle, including smack on one of the corners. You sacrifice as you move away from the corners, so in the middle you have to compromise all three cost, quality, and speed.
This is an often unrealized (and more often unrealistic) compromise.
Re:Programming Methodologies Are Dangerous (Score:2, Insightful)
your game should always be ready to ship with agile method since the most important features are done first, like the one that enables you to ship it. You may think as "milestone" versus "when it's done" but there is a third one: "when you want" and that's agile.
the misunderstanding of the methodologies is dangerous and thats why methodologies are dangerous. This is the reason I don't listen to them: if they are more intelligent than me, I would not understand them fully and make mistake, if not, they are stupid and I don't want them.
So maybe I am not talking about agile method and that post may be really useless.
Re:Agile methods suck (Score:2, Insightful)
You're doing it wrong. If desingers don't like something, it gets left to a future sprint. Remove things from a sprint by all means. You can always use the freed up time for something, but don't change things. You do have to be a little pigheaded about the rules, whilst not being totally inflexible where the system is wrong which is a tricky balance but quite possible.
And when you've got a lot of people who need to keep working together, agile methods are useless. It's great for small groups (3-4 people), but don't bother if you've got 150 people, all with complex interdependencies.
You need to simplify the interdependencies, and split into teams of less than 10 people. If team A needs something from team B, then Team A's will have to do something else this sprint.