This week's book giveaway is in the OCAJP forum. We're giving away four copies of OCA Java SE 8 Programmer I Study Guide 1Z0-808 and have Jeanne Boyarsky & Scott Selikoff on-line! See this thread for details.
I am doing a research about social impact in/of software development for one of the graduate college courses I am taking. We have to ask people for their real work experience. I chose eXtreme Programming as my topic. I thought that it would be a good idea to start a new discussion here about it. The followings are the questions I would like to ask. Any feedback will be greatly appreciated. 1. What were the benefits (in social context) you found when you implemented Extreme Programming? (Did it change your relationships with your colleague or manager? Did it change the group dynamics of your team? How did that social aspect in return affect the quality of the software you developed?)
2. What were the disadvantages (in social context) you found when you implemented Extreme Programming? (Did it change your relationships with your colleague or manager? Did it change the group dynamics of your team? How did that social aspect in return affect the quality of the software you developed?)
3. Extreme Programming has some controversial pieces (e.g. Pair Programming). When you or your organization started using Extreme Programming, how was the reaction of your colleague, your manager, or the whole of your team?
4. Related to Question 3, how did you, your colleague, your manager, or the whole of your team deal with the reaction?
5. If you have anything else your found related to social aspect of implementing Extreme Programming, please describe it here.
I'll answer a couple of questions based on my experience. I will state at the outset, though, that the project I am on is not doing pure XP. 1) It has changed the group dynamics some. As the Coach I have tried to stress that if you take on a task it is yours. The junior programmers used to always go to a senior programmer to get directions on how something should be done. Now they are more willing to think on their own or pair up without consulting with a "senior" person first. Probably the biggest change was the willingness of everyone on the team to talk with the customer (who is the founder of the client company). Only a couple of us used to speak with him on a daily basis. Now everyone does and they're not shy about calling him on his cell phone. 2) Will have to think about this. 3) Most of the team did not and still doesn't believe in pair programming to the point that they do it all the time. I think pair programming is a good thing but since I do not have the opportunity to code very much when I am given the chance I will code even if there is no one available to pair with. I do try to find someone to pair with each time. Remnding people to pair program does cause problems but nothing serious. They want you to go away and let them code. Usually I can cajole them into doing it but if I'm off running something down it doesn't get done all the time. It is definitely important to have the proper environment. Have a central area where the tubes are and there are only enough tubes to allow pair programming. We couldn't win this argument the first time around but we are going back to management and will get real XP areas set up. Sorry, that may have been offpoint a bit. 4) Think I noted that above. 5) I think you get to know your team faster using XP. It is also obvious that there are some people who don't or won't dive into it. Just like there are people who won't/don't dive into other approaches. Hope that helps. John [This message has been edited by John Wetherbie (edited November 16, 2000).]
The only reason for time is so that everything doesn't happen all at once.
- Buckaroo Banzai
Joined: Nov 16, 2000
Thank you, John. By the way, would you mind if your comments are used for my report or would you prefer to keep them only in this discussion thread? (I started this discussion thread assuming that the replies could be used for my report. But I would like to have a agreement from each person who posted a message before using his/her message. Even if I couldn't use some of the comments, I think that they are still very useful for anybody who is interested in this topic.) If you wouldn't mind that I would use your comments for my report, would you prefer that your name appear in my report or would you prefer to be anonymous? Thank you, Tad
Joined: Apr 05, 2000
Tad, You may certainly use my comments in your report. Regarding the comments being anonymous or not - could you let me know a little more about the context of the report itself. Are you planning on publishing it on the web or via some other medium? Please feel free to contact me at email@example.com or via this board. Thanks, John
Joined: Nov 16, 2000
Hi, John. We have to write a report, submit it to the instructor, and make a presentation. We are not publishing the report on the web or through any other medium. Thank you, Tad
Joined: Apr 05, 2000
OK. If you wish to use my name in the report that is fine. Thanks, John
Originally posted by Tad Takahashi: I am doing a research about social impact in/of software development for one of the graduate college courses I am taking. We have to ask people for their real work experience. I chose eXtreme Programming as my topic. I thought that it would be a good idea to start a new discussion here about it. The followings are the questions I would like to ask. Any feedback will be greatly appreciated.
1. What were the benefits (in social context) you found when you implemented Extreme Programming? (Did it change your relationships with your colleague or manager? Did it change the group dynamics of your team? How did that social aspect in return affect the quality of the software you developed?) We used pair programming in some of our classes which were teaching introduction to OOP programming (Java) here at the Dept of Informatics, University of Oslo, Norway. I can't speak for XP as a whole since this was only done on a small population and only one time, so statistically I'd be careful about concluding to much. The problem initially was that the fail percentage was fairly high after we switched from Simula (OO language since 1967 to Java. To remedy that several methods where looked at with the aim to make them better programmers at the end of the semester. The result was that when the two programmers were at the same level and the chemistry was good, these people felt support by having one extra pair of eyes and also made code with better readability and less errors.
2. What were the disadvantages (in social context) you found when you implemented Extreme Programming? (Did it change your relationships with your colleague or manager? Did it change the group dynamics of your team? How did that social aspect in return affect the quality of the software you developed?) Ofcourse, in a introductory course when you most likely don't know anyone prior to attending the course there was ofcourse a few where maybe the ambitions differed or that the chemistry and differences was too big to overcome. The result could be that one person did most of the coding while the other were inactive and did not manage to understand what all the code did. 3. Extreme Programming has some controversial pieces (e.g. Pair Programming). When you or your organization started using Extreme Programming, how was the reaction of your colleague, your manager, or the whole of your team? I'd ve sceptical about working in a pair for all my programming, but it is certainly a good thing to discuss and share code. Its often that I have some code with an impossible to find bug, but upon showing it and explaining it to a friend which knows some about the inner workings and ask some questions I usually discover the code much quicker than if I were to fiddle around by myself. 4. Related to Question 3, how did you, your colleague, your manager, or the whole of your team deal with the reaction?
5. If you have anything else your found related to social aspect of implementing Extreme Programming, please describe it here. Like it was said in another thread. eXtreme Programming is all in whole fairly extreme, but it does have some really good points which could be introduced without to much trouble. The more extreme parts could be introduced gradually on a long term and adapted to what does work in your company/situation.
Originally posted by Tad Takahashi: 1. What were the benefits (in social context) you found when you implemented Extreme Programming? (Did it change your relationships with your colleague or manager? Did it change the group dynamics of your team? How did that social aspect in return affect the quality of the software you developed?)
I've seen it in several places. Since it only really works in a properly empowered environment, it may well change the relationship with managers and "architects" since everyone has responsibility for doing their work. But I don't really have enough to generalize in a snappy way on this. The social forces in software development are both important and complicated. For more good thoughts on this Alistair Cockburn is worth looking at. XP was designed with emergent, social effects in mind.
3. Extreme Programming has some controversial pieces (e.g. Pair Programming). When you or your organization started using Extreme Programming, how was the reaction of your colleague, your manager, or the whole of your team?
You certainly do get negative reactions to Pair Programming. My view is that pairing is something you can't force. Encourage it, and let people notice that their efficiency goes up when pairing. Forcing it stops it from working.(Don't do that.)
author of:<br /><a href="http://www.amazon.com/exec/obidos/ASIN/0201485672/electricporkchop" target="_blank" rel="nofollow">Refactoring : Improving the Design of Existing Code</a><br /><a href="http://www.amazon.com/exec/obidos/ASIN/020165783X/electricporkchop" target="_blank" rel="nofollow">UML Distilled, Second Edition: A Brief Guide to the Standard Object Modeling Language</a><br /><a href="http://www.amazon.com/exec/obidos/ASIN/0201895420/electricporkchop" target="_blank" rel="nofollow">Analysis Patterns : Reusable Object Models</a><br /><a href="http://www.amazon.com/exec/obidos/ASIN/0201710919/electricporkchop" target="_blank" rel="nofollow">Planning Extreme Programming</a>
Joined: Apr 05, 2000
Martin, Noticed you put architects in quotes in your post. What is the context behind this, if any? How have you seen interactions with managers & "architects" change? I am an architect (by job title) and am currently a Coach on an XP (well, semi-XP) project. I have surprised a number of the Programmers on the program when they come to me with a problem and I ask them what they think and try to guide them to a solution with questions instead of just saying "Here's how to do it." I guess I see the Coach's role as more of a mentor than a director. What do you think? John
Joined: Dec 11, 2000
Originally posted by John Wetherbie: I guess I see the Coach's role as more of a mentor than a director. John[/B]
This is the key thing. The senior technical people here at ThoughtWorks had a dinner a couple of nights ago and we pretty much agreed to try to banish the work "architect" from the company. What we were reacting to were people we interview who say "I tell programmers how to do their work and have grown beyond coding myself". Our most effective technical leaders are coaches in the way you describe, and aren't shy to spend time pairing with developers. In my view to be a technical leader you must continue to be familiar with programming because that is the fundamental tool and communication mechanism that we all use.
That's an interesting approach. I don't object to the title architect per se but more the definition. A lot of people use an analogy between building architects and software architects along the lines of "You don't see building architects driving nails and using a saw. They come up with the basic structure of the building." I prefer the analogy to a surgeon at a teaching hospital. (I'm sure I heard or read this somewhere, just can't remember where. So my apologies to whomever I am unable to credit for this.) You set the overall "plan of attack" for the operation and then you have the more junior surgeon do most of the work and help them along. You also do some of the work (for various reasons) but an important one is that you keep your skills up. To paraphrase (Uncle) Bob: "The software industry would be doing itself a favor if it got rid of the concept of the non-coding architect". You may not be doing coding all the time but you are doing enough to stay sharp and keep current. So is your company going to open an office in Denver? John
Joined: Nov 16, 2000
Thank you, all, for posting messages. I am very glad that this discussion thread is very active. If you wouldn't mind, I would like to include your comments in my report. I will keep your names anonymous. I thought that the prefessor would ask me for the real names of the people I asked my questions to and that it would be fair to give a credit to them. But it turned out that anonymous names were acceptable. But please let me know if you prefer your real name to appear in my report. And of course, on the other hand, if you would prefer to keep your comment only in this discussion thread and not included in my report, please let me know. The semester is almost over and the next week is the last week for the course I am writing a report about XP for. But I hope this discussion thread would keep going on beyoud that. Thank you, again, everybogy, for your help. Tad
You may be interested in a feature currently going on at the Bad Managers website. Although most people seem to accept XP, Bad Managers are taking an opposing viewpoint. Makes a refreshing change! Regards, Matt.
Originally posted by Tad Takahashi: I chose eXtreme Programming as my topic. I thought that it would be a good idea to start a new discussion here about it.
Originally posted by Matt Stephens: You may be interested in a feature currently going on at the Bad Managers website. Although most people seem to accept XP, Bad Managers are taking an opposing viewpoint. Makes a refreshing change!
It could be refreshing if they were not so ill-informed.
The soul is dyed the color of its thoughts. Think only on those things that are in line with your principles and can bear the light of day. The content of your character is your choice. Day by day, what you do is who you become. Your integrity is your destiny - it is the light that guides your way. - Heraclitus
Joined: Aug 21, 2001
Ill-informed? Which part? This seems to be a common reaction from XPites - dismiss the article with a wave of the hand, without explaining why. I'm fully prepared to update the article based on constructive criticism - the article says as much. Regards, Matt.
Originally posted by Ilja Preuss: It could be refreshing if they were not so ill-informed.
XP is aimed at clueless customers who don't know what they want
The customer is required to provide user stories and acceptance tests. Obviously she has to know what she wants to be able to do this.
being guided by mediocre programmers who have even less idea what the customer wants.
The requirements (user stories) get discussed in the Release Planning and in more detail in the Iteration Planning. The customer is on site, available for answering questions "just in time". User stories are considered finished if they pass the associated acceptance tests.
in their eyes it is okay to be confused
No, it's not ok to be confused. But it's ok to change your mind.
"Don't worry, we'll just start running as hard as we can in a random direction, and if it turns out to be the wrong way, we'll just turn around. It won't cost you any extra, because turning around is free."
XPers don't start in a random direction. They start with the most important requirements, as defined by the customer. XPers don't run 'as hard as they can', they hold a sustainable pace. Changes in object oriented software are 'cheap' because of modularity - a concept that doesn't exist in running. Besides, turning around is in fact nearly free if you adjust the direction just some steps after starting. Short feedback loops are a key concept of XP.
Coding in pairs could never be as effective as one competent developer daring to think for themselves.
XP attempts to flout the physical laws of the Universe, by making it "okay" to make changes at any stage in the project.
I am not aware of any physical laws prohibiting changes at any stage in a software project.
This isn't just accepting change as a necessary evil, but positively encouraging change (even after a significant amount of code has been written)
If you learn something about the project while doing it, it seems a good thing to use these new insights to steer the project. If outer circumstances change the business value of (not yet implemented) requirements or let new requirements emerge, it seems to be nice to be able to react by adjusting the 'direction' of the project.
flying in the face of reality, convincing otherwise intelligent people who should know better, that change is somehow free.
Perhaps these intelligent people have something to share you could learn from, if you wanted to.
XP empowers programmers to make business decisions.
This is nonsense. In XP all business decisions are explicitely made by the customer.
Have XP, have spaghetti code with lots of IF statements.
In an XP project there is no place for such code. You probably missed http://www.extremeprogramming.org/rules/refactor.html? [This message has been edited by Ilja Preuss (edited September 19, 2001).] [This message has been edited by Ilja Preuss (edited September 20, 2001).]
For the purposes of this article, I have concentrated on the extremeprogramming.org website (i.e. on their particular "flavour" of XP). I am sure some will argue that this isn't the "real" XP.
I would argue that it would be dumb to judge any methodology based on a "gentle introduction".
XP does state that you don't have to practise all of it: just the parts that suit your project. From the extremeprogramming.org website: "Usually projects come looking for... XP only after the project is in trouble. In this case... figure out what is slowing you down. Add XP to this problem first..."
Continued on http://www.extremeprogramming.org/start2.html: >>>You could continue this way until no problems are left. Then just add the remaining practices as you can. [...] There is a synergy between the rules that is hard to understand until you have been fully immersed.<<<<br /> And on <A HREF="http://www.extremeprogramming.org/introduction.html:" TARGET=_blank>http://www.extremeprogramming.org/introduction.html:</A> <br /> >>>It is a collection of rules and practices each of which supports several others, and are supported by several others in turn. When they are used together a methodology emerges.<<<<br /> This is probably what he meant by somewhat overstating on <A HREF="http://www.extremeprogramming.org/what.html:" TARGET=_blank>http://www.extremeprogramming.org/what.html:</A> <br /> >>>It [XP] is a lot like a jig saw puzzle. There are many small pieces. Individually the pieces make no sense, but when combined together a complete picture can be seen.<<<<br /> BTW, you don't really need *all* pieces of a jig saw puzzle to see a picture. But the more pieces you integrated, the more complete the picture is. And you obviously always start with one piece...<br />
XP appears to be aimed at small projects. It doesn't scale. [...] How many programmers do you need? XP says 2-10 (any more and XP won't work).
<br /> From <A HREF="http://www.extremeprogramming.org/when.html:" TARGET=_blank>http://www.extremeprogramming.org/when.html:</A> <br /> >>>XP is set up for small groups of programmers. Between 2 and 10. [...] But you can not use XP on a project with a huge staff.<<<<br /> This doesn't say that huge begins by eleven programmers. In fact the definition of 'huge' would mostly depend on your experience and your definition of the boundaries of XP.<br />
This [the non-scaling] is a tad presumptious, given that they (and I, and everybody else) can have no idea what size your project is going to be.
<br /> There simply is no 'one size fits all' methodology - you will always have to adapt your process if the project size changes.<br /> On the other hand: >>>We should note that on projects with dynamic requirements or high risk you may find that a small team of XP programmers will be more effective than a large team anyway.<<< [http://www.extremeprogramming.org/when.html]<br />
How many "user stories" should your project consist of? Eighty. <br /> What I assume they're really saying is that you should start with about eighty, and take it from there.
<br /> From <A HREF="http://www.extremeprogramming.org/rules/userstories.html:" TARGET=_blank>http://www.extremeprogramming.org/rules/userstories.html:</A> <br /> >>>About 80 user stories plus or minus 20 is a perfect number to create a release plan during release planning.<<< The release plan doesn't have to span the whole project. Anything beyond a time scale of a year should be planned at a rougher level of detail.
Of course, the release plan will still result in the customer initially being quoted eighty, because nobody has thought any further ahead than that yet. ...
The planning games are not the only occasions where thinking is allowed. And - of course - the customer knows wich features aren't spanned by the stories and therefore will be handled with later.
The basic fact is that if you don't know in advance exactly what you want from your new system, then the project can't be costed. It can't have a budget (not a meaningful one, anyway). Its resources can't be accurately forecast, hence nothing can reasonably be allocated (except maybe for the upcoming two weeks).
Even *if* you knew in advance exactly what you will need in a year or two (which will be a rare case), most often the project can't accurately be costed or resources be forecast. On most projects these 'forcasts' are rather 'guesses' based on experience. The XP planning process is a reasonable way to 'guess'.
The following two rules* are true of any project. Each of these is an absolute. No "silver bullet" methodology (least of all XP) can change this reality:
This is a hard claim without any evidence, so it seems to me.
The most important decisions are made at the start of any human endeavor.
*Any*??? Makes it look like polemic to me.
This is when we address questions such as "What to do?", identify goals and select strategic plans of action.
How is this more important than "What to do know that the (known) circumstances changed?" How are strategic plans more important than tactical plans?
The cost of change increases as any project progresses. Later on [...] the interactions of thousands of decisions have increased the complexity of making change.
Doesn't help very much, as I couldn't find any information on why these should be fundamental laws of the universe. The only additional source - the diagramm - in fact makes me very skeptical. Is it implying Programming to be the first phase? What does the percent scale mean (percent of what?)? What do they refer to as typical? Where does the data come from?
Constant refactoring [...] is dangerous [...] (not to mention encouraging programmers to optimise unnecessarily)
Refactoring is encouraging developers to optimise maintainability and extensebility, which XP deems necessary. It is not at all encouraging to optimize performance, as this will most often conflict with those two properties. See http://www.extremeprogramming.org/rules/optimize.html.
Unit tests may introduce more bugs than they prevent because you've now got twice as much code
That's just silly.
and a change to the mythical requirements means many changes to all that source code
Modularity at work: most changes will have very local impact.
and testing the tests to make sure they still reflect the requirements, that is if anyone had them written down somewhere
They are - in the acceptance tests. They tell you automatically if you broke something.
Is the customer really going to spare a senior decision-maker for an entire year?
If she is serious about the project, she will. And she will save money by doing it. BTW, being an onsite customer is not necessarily a full time job.
and we're back at the start of the loop.
No, it's not a loop, even the way you presented it - carefull reading of pair programming and onsite customer paragraphs should make this obvious. Anyway, your presentation of the dependencies is an intense oversimplification.
From extremeprogramming.org: "The release plan used to be called the commitment schedule ... A useable, testable system that makes good business sense delivered early is desired" Now let's see: Useable... yes; testable... yes; makes good sense, yeess... delivered early? Hang on a second. I have had the unfortunate privilege of knowing a good few managers who would take this implicit promise as a sign to over-promise to the customer: "Our team say this defence project will take them 16 months to complete. But wait just a second, they're using this project to try out XP! That means I can just go ahead and promise the customer half that time instead. Way to go guys!"
In XP this wouldn't happen, as the customer is present at the planning meeting, actively defining what should get 'delivered early' (after the first iteration of one to three weeks) and what should get delivered later.
Software isn't an amorphous gooey substance that can be shaped, moulded and re-shaped as you go along.
Yes, it is - if you make it that way! That's one of the things that is so cool about XP.
Whatever the XP-ites tell you, there's a cost penalty involved.
There is also a cost involved in not being able to reshape the system to new needs. There is a cost involved in not being able to hold complexity to minimum as the system evolves. There is a big cost involved in trying to analyze the whole big system in detail up front. XP assumes that with modern tools and techniques, the cost of reshaping the system pays back manyfold. To be continued... [This message has been edited by Ilja Preuss (edited September 23, 2001).] [This message has been edited by Ilja Preuss (edited September 23, 2001).]
Again, most (if not all) of your comments are answered in the "Ron's Rebuttal" page, linked to from the above URL. I hope you'll forgive me if I don't repeat the answers here.
There is also a cost involved in not being able to reshape the system to new needs. There is a cost involved in not being able to hold complexity to minimum as the system evolves. There is a big cost involved in trying to analyze the whole big system in detail up front.
XP definitely has some good ideas (borrowed from conventional methodologies, as Kent Beck admits) - unit/acceptance testing, keeping it simple, coding by intention, etc. I can write simple, maintainable code, with well-defined interfaces, sub-systems and components, without resorting to XP. Making changes is easy, because we did a big design up front.
XP assumes that with modern tools and techniques, the cost of reshaping the system pays back manyfold.
As Kent Beck asserts in XP Explained, pretty much all of XP's benefits rest on his claim that XP can flatten the cost-of-change curve. It's this claim that I find the most dubious. Sure, the cost of adding new functionality may be "flattened" (or even decrease as the project progresses), but this is very different from actually making functional changes (not just refactoring). Where classes have grown to be dependent on each other, there will inevitably be a cost penalty in changing a user story and all the classes that implement it. However minimal the change, it still isn't "free". Regards, Matt.
Originally posted by Matt Stephens: As Kent Beck asserts in XP Explained, pretty much all of XP's benefits rest on his claim that XP can flatten the cost-of-change curve. It's this claim that I find the most dubious.
Matt, Your article pretends to disspell myths and misconceptions about XP. Yet throughout the article you repeat the most common misconceptions about XP: how it uses design, refactoring, unit testing, integration, pair programming, etc. IMHO, your article fails miserably and only succeeds in showing that you misunderstand the essence of XP as much as anybody else who hasn't taken the time to sit down and look at it objectively. All your arguments in the original article and rebuttal to Ron's rebuttal seem to be based on fear and ignorance. Alistair Cockburn (http://members.aol.com/acockburn), on the other hand, wrote a very good article on his doubts about XP's flattened cost-of-change curve. His re-examination of it can be found at http://www.xprogramming.com/xpmag/cost_of_change.htm Despite his doubts, Alistair is a proponent of XP-like methodologies (he just finished writing his latest book "Agile Software Development". But you probably already know this. At least, I think you should. I am curious: do you have actual experience with XP or XP-like methodologies? Don't you think it unfair to criticise XP without even so much as trying it out for yourself? Kent Beck, Martin Fowler, Alistair Cockburn, Jim Highsmith, Tom DeMarco, and many others. All pioneers/leaders in our profession. Each with considerable knowledge and experience with software development methodologies. And yet now they all choose to fall back to simpler and more agile practices and have succeeded with them. Your article was an interesting read. However, I think I'll listen to the folks who seem to know what they're talking about. --- Junilu Lacar [This message has been edited by JUNILU LACAR (edited October 21, 2001).]
Originally posted by Matt Stephens: Ill-informed? Which part? This seems to be a common reaction from XPites - dismiss the article with a wave of the hand, without explaining why. I'm fully prepared to update the article based on constructive criticism - the article says as much.
Matt, IMHO, almost the entire article is based on ill-informed opinion. And perhaps it's not a dismissal type wave of the hand but more of a I-don't-where-to-start-since-you've-got-it-all-wrong raising of hands. For starters - refactoring, if done correctly, is not about "tweaking and unnecessary optimizing" nor should it introduce more bugs. If you look a little closer at the front of Martin Fowler's book, it clearly states that it's about "improving the design of existing code". Refactoring is done so that you can add new functionality without resorting to kludges or workarounds. Refactoring is about re-evaluating your design and making changes so that new functionality can be added and still have code that conforms to good design principles. Most of the views you present about the different practices drip of cynicism. You obviously present scenarios for pair programming, refactoring, unit testing, etc. that any sensible person would agree would not work. But then again, the scenarios you present wouldn't happen with true XP. I think you should try to present more objective criticisms and try to see if there is some way that these practices could actually work. Those whom you perceive as being dismissive probably already know that they work. ------------------ Junilu Lacar Sun Certified Programmer for the Java� 2 Platform [This message has been edited by JUNILU LACAR (edited October 21, 2001).]