Slashdot Mirror


Beck and Andres on Extreme Programming

narramissic writes "In recent years, Extreme Programming (XP) has come of age. Its principles of transparency, trust and accountability represent a change of context that is good not only for software development but for everyone involved in the process. In this interview, Kent Beck and Cynthia Andres, co-authors of 'Extreme Programming Explained: Embrace Change,' discuss how XP makes improvement possible."

321 comments

  1. Extreme... by celardore · · Score: 4, Funny

    I was hoping for something a little closer to Extreme Ironing.

    That would have been cool.

    1. Re:Extreme... by pnone · · Score: 2, Funny

      There is also one good tool called Petra supporting extreme programming prototyping http://petra.cleverlance.com/ We use it and love it.

    2. Re:Extreme... by Thalagyrt · · Score: 1

      I'm not the only one who saw the article and pictured a guy coding on a laptop while snowboarding down some crazy mountain and trying to avoid the falling avalanche, am I?

      --
      Buffalo buffalo Buffalo buffalo buffalo buffalo Buffalo buffalo!
    3. Re:Extreme... by shreevatsa · · Score: 2, Funny

      Nah, Extreme Programming is cool enough.

    4. Re:Extreme... by mbadolato · · Score: 1
      I'm not the only one who saw the article and pictured a guy coding on a laptop while snowboarding down some crazy mountain and trying to avoid the falling avalanche, am I?

      Um, Pair Programming is a huge tenet of eXtreme Programming, so CLEARLY the programmers are coding on a laptop whilst skydiving in tandem.

      Skiing down a mountiain... Wassamatta wit' you? Sheesh... ;-)

    5. Re:Extreme... by Thalagyrt · · Score: 1

      Come on! This is Slashdot! We don't RTFA here! So how would I have known there were pairs involved? =P Sheesh!

      --
      Buffalo buffalo Buffalo buffalo buffalo buffalo Buffalo buffalo!
  2. Article's dated 6th May 2005.... by popeyethesailor · · Score: 2, Insightful

    This is too extreme even for slashdot...

    1. Re:Article's dated 6th May 2005.... by Anonymous Coward · · Score: 1, Interesting

      I spent large parts of the 80's programming with a salesman sitting behind me saying things like "You've spelt that wrong" or "that won't work" or "why are you doing it that way?"

      As far as I'm concerned, if anyone ever suggests I should program in pairs with someone again, I'm going to reach for my flamethrower.

    2. Re:Article's dated 6th May 2005.... by gbjbaanb · · Score: 2, Funny

      I don;t know about that - I think pair programming is great. think:

      What do you need to pair progam? development software, check. monitor, keyboard, check. coffee, check. newspaper check.
      Right, divvi that up between the pairs evenly, you get the software and PC, I get the coffee and newspaper. See how pair programming works? :-)

    3. Re:Article's dated 6th May 2005.... by chromatic · · Score: 1

      Doesn't the word "again" imply that you've done it before? I don't know what you described, but it has nothing to do with pair programming.

    4. Re:Article's dated 6th May 2005.... by Devil_Hack · · Score: 1

      I completely aggree with you here. In the OO Programming course I had this year, they encouraged us to practice extreme programming. Well, it sucked... Everytime my partner and I encountered a little problem and one of us had an idea, he had to explain it to the other, which took at least 3 times as long as just typing it out, which in almost every case made the idea perfectly clear. Suffice to say, after about 4 hours we gave up and just sent each other any files we had edited (of course making sure we didn't work on the same file at the same time).

    5. Re:Article's dated 6th May 2005.... by AuMatar · · Score: 1

      If the project is sufficiently long (over a day) you might want to set up a CVS or Subversion repository. Otherwise thats exactly what I'd do too.

      --
      I still have more fans than freaks. WTF is wrong with you people?
    6. Re:Article's dated 6th May 2005.... by Shambhu · · Score: 1
      Everytime my partner and I encountered a little problem and one of us had an idea, he had to explain it to the other, which took at least 3 times as long as just typing it out, which in almost every case made the idea perfectly clear.

      That doesn't really add up. If typing the solution was usually sufficient to explain it, then how was it that explaining would take three times as long? I mean you just type, point at the screen .... maybe grunt a little.

      Maybe it was convincing each other took that three times as long as typing the solution, but that would be perfectly acceptable.
      --
      Rome wasn't bilked in a day.
  3. Overrated by seti · · Score: 2, Insightful

    In my opinion, extreme programming is extremely overrated. Some of the ideas, such as test-driven development (although this concept is not restricted to XP), work well. Others, such as pair programming just do not work in my opinion. Programmersare solo beasts - putting two of these dragons behind one keyboard is asking for trouble.

    --
    Coca-Cola, sometimes War.
    1. Re:Overrated by Ed+Avis · · Score: 1

      'in your opinion'... how many times have you tried it?

      --
      -- Ed Avis ed@membled.com
    2. Re:Overrated by joshetc · · Score: 1

      He clearly states 'in my opinion' not 'in my experience'.

    3. Re:Overrated by hclyff · · Score: 5, Insightful
      Others, such as pair programming just do not work in my opinion. Programmersare solo beasts - putting two of these dragons behind one keyboard is asking for trouble.
      Pair programming can be seen as a kind of code review, but with the reviewer in equal position with the programmer. Traditional code reviews tend to be frustrating for the programmers, because the reviewers are in position of authority.

      But when you put two programmers with equal authority, you have one thinking about the bigger picture and the other reviewing his mind flow. At the same time the later is writing down the ideas in code, with the first one reviewing his code as he types.

      Programmersare solo beasts
      Where have you been the last 20 years? The stereotypical programmer, hacking his piece of kernel over night is very endangered species, and rightly so. Like any kind of engineering, software engineering needs as much face to face collaboration as possible.
    4. Re:Overrated by Aladrin · · Score: 2, Insightful

      I mostly agree. However, you've forgotten that not all programers ARE like that. Some do actually work well when that close to someone else. I would love to find another programmer of my level (too much higher or lower would cause many problems, I'm sure) and try it. I suspect I'm too hard-headed-control-freak to allow someone else to do things while I just watch, even half the time. But there are people who can and DO do pair-programming and produce code faster, with fewer mistakes.

      Unit testing is my new best friend, btw. It has helped me find so many issues and even prevent issues that I can't exist without it now.

      --
      "If you make people think they're thinking, they'll love you; But if you really make them think, they'll hate you." - DM
    5. Re:Overrated by BiggerIsBetter · · Score: 2, Insightful

      Like any kind of engineering, software engineering needs as much face to face collaboration as possible.

      You really think XP is Engineering?

      --
      Forget thrust, drag, lift and weight. Airplanes fly because of money.
    6. Re:Overrated by Scarblac · · Score: 1

      You often see arguments like this... I like this part, I think that part doesn't work well...

      The XP books make very clear that it's either all or nothing. They don't claim that pair programming by itself is always useful, they just claim that this whole set of techniques taken together is useful. If you're going to do all the other things XP says, XP says you should combine it with pair programming.

      If you're not using all the elements (on-site client, pair programming, collective code ownership, etc etc etc), then you're not doing XP.

      Personally I think pair programming greatly boosts performance, if only because it usually stops them procrastinating on Slashdot.

      --
      I believe posters are recognized by their sig. So I made one.
    7. Re:Overrated by TechnoBunny · · Score: 1

      I disagree. Most programmers have, at some point or another, had an 'OMG - why on earth did I do that?' moment. You simply dont get them with two sets of eyes on each line. In effect, you're getting not only line by line code reviewing going on, but its happening in the context of those lines being written. The code only gets committed if *both* developers are happy - and that is a sure way to increase the quality of code, since the foibles of an individual are subsumed.

    8. Re:Overrated by aadvancedGIR · · Score: 1

      I tried a few work modes and I agree. What I consider to work best is to code solo with a main reviewer who participate to the conception phase, checks everything you deliver (code, docs and test plan) and is able to pass the test (and to correct crical bugs if you are on vacation). This way you get most of the advantages of pair programming but without the worst drawbacks: the reviewer knows what he is talking about and usualy gives far better comments than the random external reviewer and since everyone has a clear responsibility, no one can leech and get away with it.

    9. Re:Overrated by darkchubs · · Score: 1

      haha I recall being in a "team pair" and the who ever was doing the typing (AKA: the hot seat).. was doing cart wheels through a land mine farm. Should he forget a { or ; then .. the other guy would yell it out as if we were playing pictionary... and it became EXTREAMLY ANNOYING. Programmers can be kinda .. well catty

    10. Re:Overrated by StrawberryFrog · · Score: 1

      Programmers are solo beasts

      Really? So what percentage of major, important or commonly used programs were written by only one person?

      --

      My Karma: ran over your Dogma
      StrawberryFrog

    11. Re:Overrated by Angst+Badger · · Score: 4, Insightful

      Pair programming can be seen as a kind of code review, but with the reviewer in equal position with the programmer. Traditional code reviews tend to be frustrating for the programmers, because the reviewers are in position of authority.

      I've never seen one of those. Every code review I've participated in has been a collaborative effort between peers. If you treat a code review as a cooperative effort between programmers, it doesn't have to be frustrating.

      Like any kind of engineering, software engineering needs as much face to face collaboration as possible.

      To a point. But real engineering requires planning and clear interface definitions, and XP -- almost to the point of being pathological -- attempts to avoid planning as much as possible by subsitituting endless chatter and tremendous time wasting repeatedly reimplementing what could have been done right the first time. (And yes, I know some things always have to be reimplemented, but just because mistakes are inevitable doesn't mean they have to be encouraged.)

      Software development has an unfortunate tendency towards fanatical adherence to the latest silver bullet. Usually, this involves an implementation language backed by a marketing push; XP seems to be the first programming fad built entirely on book publishing. But then, no implementation language ever actively encouraged the kind of passive-aggressive personality that thrives on XP.

      --
      Proud member of the Weirdo-American community.
    12. Re:Overrated by Peter+La+Casse · · Score: 2, Interesting
      In my opinion, extreme programming is extremely overrated. Some of the ideas, such as test-driven development (although this concept is not restricted to XP), work well. Others, such as pair programming just do not work in my opinion. Programmersare solo beasts - putting two of these dragons behind one keyboard is asking for trouble.

      Test driven development is seductive; who wouldn't want to have all those automated tests in order to check changes to their code? However, I find it hard to put into practice. When requirements change frequently (which XP is supposed to be geared towards) it's hard to complete the tests much less complete the code before we're asked to change something, and changing even a small piece of code often requires changing a lot of tests. If you can offer any suggestions about how to improve that, I'm all ears.

      Pair programming, on the other hand, is something that I wish I could have done when I was fresh out of school and not really as smart as I thought I was. It seems like an effective way to show the newer programmer how the veteran does things, both in the code and in how the day is scheduled.

    13. Re:Overrated by Spicerun · · Score: 5, Interesting
      I worked under it for at least a year. Its another one of those methods that looks good on paper, but sucks in practicality. What's unpracticle?

      1. No company in their right minds wants to pay for TWO programmers to do a single job. But then, again, you can always get 2 programmers at half-price to do the job (and have half the quality of one full price programmer).

      2. As with any other method, it assumes all the specs and implementation have been worked out before the code is even written....nobody has the freedom to write experimental throwaway code to even see if their approach is even feasible in the coding, or, if programming a device, if the device will even work with the approach being made (for you people not in the embedded world, most device datasheets are incorrect and seldom get corrected).

      3. While its great at letting the mundane functions be rewritten (refactored) as many times as possible, it gives a mechanism where newer features are *always* put off (by managers usually) indefinitely....its an illusion, under a few managers, that the programmers will ever get to implement the newer features wanted by customers (its amazing how most new features are always rated as low priority by someone other than the customer....even more amazing about how many 'stories' aren't written by the customer.).

      4. Even in the XP books it is explained that XP is not meant to work for every single software environment/situation....yet there are managers who will do their best to try to force it to work when it won't.

      I always find it really is better for a group of Programmer Peers to sit down together and review the code AFTER it has been written (with tests). Trouble is, most companies/managers refuse to understand that 'Programming Peers' do not include the stock boy in shipping.

      Just my $.02. Can you tell I didn't really like being under the XP model myself?

    14. Re:Overrated by Anonymous Coward · · Score: 1, Insightful

      Yup. People make a mistake when they try too much to base software engineering on other engineering disciplines, and copy the practices over intact. Successful engineering is not defined by the scaffolding used to build a product; it's defined by successful products. Saying that XP isn't engineering because it eliminates much of the scaffolding (documentation, big-design-up-front) from traditional waterfall processes is missing the point of engineering altogether.

      I imagine the same response from old-school manufacturers, responding to Toyota's lean manufacturing model that we learned about in the 80's. No inventory? You consider this real manufacturing?

    15. Re:Overrated by Anonymous Coward · · Score: 0, Insightful

      Open your eyes. XP when followed properly is a form of software engineering. I'm not going to waste my time explaining what engineering is to you when you can easily look it up for yourself. I'm a Computer Engineer and have recieved great praise from more traditional engineers due to my skills and abilities compared to traditional IT. Engineering is a set of tested princibles and codes of ethic applied to a given field.

    16. Re:Overrated by Rungchen · · Score: 1

      I agree that it is, as any 'great' programming paradigm, XP is overrated. But I think you are extremely unfair in your absolute judgment over it.
      I have good experience using various parts of it. Pair programming one of them, though I didn't know what it was called, before XP labeled it.
      Actually. A lot of the bad code you see around stems from 'lone ranger' coders, not realizing the fact that, programming like most other disciplines, is collaborate work.
      Except for kitchen table projects most code is written with other people. Other programmers, designers, project managers, users ( damned be the last two) , and other stakeholders. XP addresses a lot of the problems you have when collaborating with these and so it can help you to get more time to code.

      BTW: If it is the prospect of social contact that frightens you, just, develop a severe case of schizophrenia and pair up with the other you;-).

      --
      You can get it fast, you can get it good, You can get it cheap. Pick two!
    17. Re:Overrated by Peter+La+Casse · · Score: 5, Insightful
      You really think XP is Engineering?

      It's an attempt to achieve a greater level of quality through process/practices, which is as close as "software engineering" has gotten to real engineering so far. Arguably, though, "software engineering" isn't real engineering until you use formal methods to ensure the correctness of your design and implementation.

    18. Re:Overrated by recordMyRides · · Score: 1

      The other advantage is that you spend less time reading /. when there's another person sitting next to you.

      Guess I ought to get to work. . .

    19. Re:Overrated by CastrTroy · · Score: 2, Interesting

      Pair programming may stop people from wasting time on slashdot, however, they seem to waste time in a lot of other ways. Like whether a specific for loop should be written as for(i = 0;imyArray.length();i++) or as for(i = 0;i=myArray.length()-1;i++). That and whether the opening brace should be on same line following the for statement, or on the next line. Oh, and whether certain things should be put in functions, or put inline in the code. Peer programming, while I can see the advantages of having someone sitting there, watching you, and correcting you as you go along, also has a lot of downsides. I often program in a very non-linear way. Sometimes i'm aware that I've made a mistake, but finish typing out my entire thought before I go back and correct it. Whenever I have someone watching me, and they point out the mistakes, telling me to go and correct something, I often lose my train of thought. It's like to writing a story and having somebody make you go back and correct all the grammar mistakes before while your done trying to get your thoughts out.

      --

      Anthropic principle: We see the universe the way it is because if it were different we would not be here to see it.
    20. Re:Overrated by njdj · · Score: 1

      Traditional code reviews tend to be frustrating for the programmers, because the reviewers are in position of authority.

      That's because most organizations don't know how to run code reviews properly.

      For example, the reviewers should not be in a position of authority. Their role is to raise issues with the code. How to resolve those issues is entirely at the discretion of the programmer. Whether an issue requires any action at all is the programmer's decision.

      Most programmers want to do excellent work, and will use the comments from the review to improve their code. If you have a programmer who does not want to do excellent work, the whole exercise is pointless - but if you have a programmer who does not want to do excellent work, you are in trouble in any case.

    21. Re:Overrated by MobyDisk · · Score: 1

      If it isn't engineering then you are doing it wrong.

      I recommend Extreme Programming Refactored if you are interested in taking the best parts of extreme programming and mixing them with a traditional waterfall approach to make a nice form of "moderate programming."

    22. Re:Overrated by utnapistim · · Score: 1
      Others, such as pair programming just do not work in my opinion.

      I haven't had long-term experience with pair programming, but from what I've tried it was cool. This involves a lot of issues to be agreed on beforehand, and respected, like the fact that "inactive guy" needs to actually be very active (follow the logic of the "hot seat", look for mistakes, watch the coding style and so on).

      It also involves that the members of the pair are really equal (otherwise you have no pair there and the bennefits dissapear).

      When writing code, it's good to have someone watching what you're doing, while you're doing it and being in tune with it (helping when you miss stuff, like "don't forget to increment the index" or "add a comment explaining that because it will look weird", or "we need to recalculate this here, because it might have changed").

      I realize this can easily turn to nagging or become annoying, but with a bit of care in the team, you can avoid those situations (some people really are not fit for pair programming but that doesn't make the technique invalid).

      When being the inactive coder, you can learn stuff, get a better overall perspective, relax more while working (actually both positions are more relaxing than solo-programming), and do pier review at the best possible moment (while the code is actually being written).

      --
      Tie two birds together: although they have four wings, they cannot fly. (The blind man)
    23. Re:Overrated by Aladrin · · Score: 1

      That's an advantage? I'm doing something wrong then...

      --
      "If you make people think they're thinking, they'll love you; But if you really make them think, they'll hate you." - DM
    24. Re:Overrated by Anonymous Coward · · Score: 0

      It is if you can get it to work.

    25. Re:Overrated by MobyDisk · · Score: 5, Interesting

      I found pair programming to be very efficient. But it depends on how you pair people.

      (Summary of my best practices article)

      Junior developer alone: Can complete the project but with errors a senior developer could have fixed. Code reviews fix this, but are tedious.
      Senior developer alone: Good code, but this tends to breed "cowboy coders" and doesn't pass on knowledge.
      Senior + Junior: Highly effective, but only if the Junior developer is the one at the keyboard.

      Other combinations can help, but aren't superb. I recommend pair programming (1) on tedious code, (2) to spread knowledge, and (3) when refactoring something crucial.

    26. Re:Overrated by blowdart · · Score: 3, Insightful

      But all or nothing is not just an XP problem. All methodologies say their way is best, if you deviate you are a heretic and if it all fails then it's your problem for not following the rules. The people that "invent" a methodology make their money from teaching people how to do it, why would they kill their cash cow by telling people they should just take the bits that work for them? Methodology advocates, like preachers cannot afford to have people think for themselves.

    27. Re:Overrated by g2devi · · Score: 1

      > Pair programming can be seen as a kind of code review, but with the reviewer in equal position with the programmer.

      It depends on the personalities. It likely works well if you have a uniform team, but it you have a diverse team (which is a good thing since your weeknesses are compensated by someone else's strengths), it can be very suboptimal. For instance, if you put a reflexive analytical introvert with a shoot from the hip intuitive extrovert, the extrovert will more than likely steamroll over most of the input of the introvert and feel validated because the shoot from the hip extovert thinks that the code has the approval of the reflexive analytical programmer.

      In the case of a code review, the reflexive analytical introvert gets to do things the way he/she wanted to do and gets input during the review from the extrovert if there are alternate ways of doing things. More than likely, it's also learning experience for the shoot from the hip programmer to program more safely. In the reverse case, the shoot from the hip intuitive extrovert gets to do things the way he/she wants and gets validation that that code is safe and handles all conditions. It's also likely a learning experience for the reflexive introvert to see that "crazy new techniques" can actually be better.

    28. Re:Overrated by ClosedSource · · Score: 1

      I've had similiar problems with it. It's also very difficult to get the balance of effort right. If you pair someone who has strong religious beliefs about the "right" way to do things with another who is more flexible, it ends up being more efficient to let the religious one "drive".

    29. Re:Overrated by ClosedSource · · Score: 2, Insightful

      "Most programmers have, at some point or another, had an 'OMG - why on earth did I do that?' moment"

      Sure, but the question is what percentage of the time does this happen and is it often enough to justify tying up two programmers all the time.

      "The code only gets committed if *both* developers are happy - and that is a sure way to increase the quality of code, since the foibles of an individual are subsumed."

      That's an idealistic view. It would be more accurate to say the code gets committed when the more aggressive developer is happy.

    30. Re:Overrated by Anonymous Coward · · Score: 0
      Unit testing is my new best friend, btw. It has helped me find so many issues and even prevent issues that I can't exist without it now.

      "new best friend"? "can't exist without it now"? What in the seven hells were you doing before?

      I suspect you're the type of programmer who would benefit very much from pair programming -- one who has no idea what the hell he should be doing, and needs a nursemaid to watch your every move.
    31. Re:Overrated by ClosedSource · · Score: 1

      It seems to me that test driven development is a great way to generate throw-away code. Writing solid unit tests after you have written the code, provides the same benefits as writing it before except you don't have to write as many incremental tests.

    32. Re:Overrated by Anonymous Coward · · Score: 0

      Quite right... it's also a poor choice of name. Whenever anyone mentions extreme programming to me, I always imagine them in a bobblehat, skisuit, wearing mirrored sunglasses and with their mouth wide open; tongue stuck out and their index and little fingers extended. Wankers. I makes me want to punch them, the pepsi max twats... even if they are actually just a small fat geek wearing coke-bottle glasses.

    33. Re:Overrated by Eivind+Eklund · · Score: 1
      Some programmers are solo beasts. Some are not. And it really depend on who they are collaborating with, and the setting around it.

      Have you noticed the "with snacks" meme that is going around everywhere in XP? "We don't know why, but this works much better when there are snack available in reach of the programmers." This one is true, in my experience. Pair programming work much better with it in place...

      Eivind.

      --
      Doubting the existence of evolution is like doubting the existence of China: It just shows that you're uninformed.
    34. Re:Overrated by Carl+Rosenberger · · Score: 1

      Whenever I see a comment that pair programming does not work I feel sad for the person that wrote it. Maybe you were very unlucky with the peer you were working with, maybe you were unlucky with the task that you were working on.

      Without pairing my work would only be half as much fun and I would really miss the opportunity to learn from other people.

      Some thoughts taken from a recent blog post that I wrote:

      - Pairing keeps you completely focussed on a single important task. This benefit alone at least doubles the productivity of every developer and makes pairing cheaper.
      - Pairing produces better designs that last longer.
      - Pairing prevents simple mistakes and saves you from loosing time in the debugger.
      - Pairing fosters shared knowledge about the project that is being worked on. It makes it easier to exchange people between tasks.
      - Pairing helps learning. People teach eachother programming techniques, patterns and ways of working with IDEs.
      - Pairing helps raising the spirit of the team. It has worked extremely well to glue our team together, although we only see eachother in real life twice a year.
      - Pairing activates the speech area of your brain and makes you more creative.
      - Pairing is fun.

    35. Re:Overrated by TheRaven64 · · Score: 1
      Like whether a specific for loop should be written as for(i = 0;imyArray.length();i++) or as for(i = 0;i=myArray.length()-1;i++).

      I don't know what language you are using, but it almost certainly shouldn't be written that way unless you are performing an operation in the loop that changes the number of elements in the array. Unless your language allows you to specify that the length() function is a pure function (and all other array methods you use are, then you will be testing the length of the array every iteration. If your framework supports iterators / enumerators then you should be using these instead; ideally via a 'for each' language construct or macro.

      --
      I am TheRaven on Soylent News
    36. Re:Overrated by Eivind+Eklund · · Score: 2, Interesting
      It actually works good even with a large experience/skill disparity between the programmers. I've only had the experience from the senior perspective - the juniors have said it worked well for them too. As they're still my friends (even though I've quit working with them), I believe them :)

      Eivind.

      --
      Doubting the existence of evolution is like doubting the existence of China: It just shows that you're uninformed.
    37. Re:Overrated by Stooshie · · Score: 1

      You should have coding standards in place where that kind of thing is sorted out before coding starts anyway.

      --
      America, Home of the Brave. ... .and the Squaw.
    38. Re:Overrated by raduf · · Score: 1


          It's a matter of relationship. Last time (a long ago) when i did pair programming it was lots of fun and very useful. The one writing code took care of the micromanagement and had in mind at most the function he was working on, and the other was two steps ahead. If the side man keeps checking syntax and formating then the whole thing is useless.

    39. Re:Overrated by Eivind+Eklund · · Score: 1

      Have you actually tried XP? Because to me, what you write sounds like somebody that hasn't tried it, and just feel that this can't work, and passive-aggressively accuses those that have tried it and found it to work of being passive-aggressive ;)

      --
      Doubting the existence of evolution is like doubting the existence of China: It just shows that you're uninformed.
    40. Re:Overrated by Anonymous Coward · · Score: 0

      Except, of course, that at the end, you usually are neither given the time to create the tests nor the opportunity to run them.

      What XP tries to do, with its "whole-shebang" methodology, is to build in safeguards in the process so that neither managers nor programmers can avoid them - thus the "pair programming == code review" - "ooh, cheaper and *on* time" says the manager, "oooh, only 50% of my time spent wasted on reviews" thinks the programmer - test-driven development, "whoa, tests that proves that the code works!" from the programmer, "finally no darn test phase that people want to spend *weeks* on" from the manager.

      It is a nifty trick, because the intention is to allow for radical improvement of both efficiency and pleasure of work. That said, many of XPs particular tips can be used seperate from XP as a whole.

      Do remember that the choice is not always between "unit-tests" and "test periods", it can be between "unit tests" and "no tests."

      XP can work as an excuse to be able to do good work. While one could say "well, change workplace then!" that is not something that is viable or possible for everyone.

    41. Re:Overrated by aaribaud · · Score: 1

      Sorry to ask, but can someone give an example of a field of "real engineering" which uses formal methods to ensure correctness, and of the formal methods used?

    42. Re:Overrated by vhogemann · · Score: 2, Insightful

      I enjoy pair programming, really.

      Quite often it prevents me from doing very stupid errors. Having another person looking at what you're doing, and making questions about that pice of code, and suggestions makes you pay more attention, and gives a precious feedback.

      Also, when I'm co-piloting (not at the keyboard, that is) I feel this incredible urge to return to my desktop and code something. Watching other people code, and talking about his code makes me want to code, its weird, but I always feel more motivated after a pair programming session.

      Of course there are times when I don't want anyone looking over my shoulder, but that's normally happens when I'm playing Nexuiz DeathMatch ;-)

      --
      ---- You know how some doctors have the Messiah complex - they need to save the world? You've got the "Rubik's" complex
    43. Re:Overrated by Stooshie · · Score: 2, Interesting
      ... and changing even a small piece of code often requires changing a lot of tests. If you can offer any suggestions about how to improve that, I'm all ears.

      That's the wrong way round. Shouldn't you be rewriting the tests to conform to the new specifications then changing the code for the re-written tests that fail? Doing it your way will make it very difficult to trace code.

      Another way of pair programming could be to have one person writing the tests and one writing the code.

      --
      America, Home of the Brave. ... .and the Squaw.
    44. Re:Overrated by sammy+baby · · Score: 3, Funny
      Your post reads like a summary of the book, "Extreme Programming Refactored: The Case Against XP," by Stephens and Rosenberg I recommend it for everyone, including people who are using XP successfully.

      If nothing else, it's worth it just for the song lyrics:

      Eight Builds a Week

      (Sing to the tune of "Eight Days a Week" by The Beatles)

      Livin' in a timebox
      Guess you know it's rough
      Gotta build every day, babe
      Even half-baked stuff

      Build it, ship it
      Build it, ship it

      Ain't got time for design, babe
      Eight builds a week

      Build it every day, babe
      Build it right on time
      One thing I can say, babe
      No time for design

      Refactor it, test it
      Build it, ship it
      Ain't got time for design, babe
      Eight builds a week

    45. Re:Overrated by NoPhD · · Score: 1

      See http://www.martinfowler.com/bliki/C3.html. Sounds to me like your on the right track.

    46. Re:Overrated by CastrTroy · · Score: 1

      You just proved my point. Really in the end, it doesn't make that much of a difference whether you use for each, ilength, or i = length -1. I mean, you could argue that it's more efficient to use a for each, but do you really know what's going on under the hood, and whether or not it's just checking the length function anyway. How do you know you're at the end of the array unless you check the length? I guess you could be checking a variable instead of calling a function, but unless you're going for the ultimate in performance, in which case you'd be better off programming the thing in assembly, then it isn't going to matter.

      --

      Anthropic principle: We see the universe the way it is because if it were different we would not be here to see it.
    47. Re:Overrated by E++99 · · Score: 1
      Programmersare solo beasts
      Where have you been the last 20 years? The stereotypical programmer, hacking his piece of kernel over night is very endangered species, and rightly so. Like any kind of engineering, software engineering needs as much face to face collaboration as possible.
      Right, come on! Everyone knows that all programmers are extroverts! Programming should be a social event! Besides, the dramatic spike in programmer suicides will only drive up the average salary. If you don't think that the XP model works, just look back at the great collaberative works by the master artists of the renaissance... like, um... well there IS this collaberative mural in the subway, and it looks... well, WAY better than bare cinder block!
    48. Re:Overrated by morgan_greywolf · · Score: 1

      Pair programming can be seen as a kind of code review, but with the reviewer in equal position with the programmer. Traditional code reviews tend to be frustrating for the programmers, because the reviewers are in position of authority.

      Notice that he said 'programming peers' -- the coders on the development team sit down, without management, and peer review the code.

      This is why the open source development model works so well -- all the developers are essentially peers working together on the same project. They review each others' code and a work out what needs to be fixed, what can be improved, etc.

    49. Re:Overrated by computational+super · · Score: 1
      Most programmers have, at some point or another, had an 'OMG - why on earth did I do that?' moment.

      Yeah, I have one of those every time I decide to try XP.

      --
      Proud neuron in the Slashdot hivemind since 2002.
    50. Re:Overrated by Anonymous Coward · · Score: 0

      I agree totally. Have tried it, currently fored to be doing parts of it, and something that I will definitely take into consideration when looking for the next job.

    51. Re:Overrated by Mikkeles · · Score: 1

      Structural engineering - analysis of components and connections based on the science of strength of materials.
      Aeronautical engineering - design is based on computer simulation of air flows over wings and fuselage, then confirmed by testing, which is not antiethical to formal methods of physical components.

      --
      Great minds think alike; fools seldom differ.
    52. Re:Overrated by Anonymous Coward · · Score: 0

      Hi Eivind,

      Every so often some new buzzword-laden methodology comes along to further politicize the software development environment.

      Remember the CASE fever that was going around in the early nineties? That was a somewhat predictable outcome of its predecessor fad, Artificial Intelligence. Remember how programs were supposed to take over the job of programming?

      Here's the honest truth folks to paraphrase Edsger Djikstra: Programming computers is hard work, only a few truly excel at it. The reason it is so expensive is because it is tried with cheap labor.

      Like all other fads in the software development biz eXtreme Programming codifies a few useful techniques which will survive the test of time (but many of these are simply reformulations of existing practice). As far as fads go I don't expect it to last very long though.

      One thing I am quite sure of however. XP will serve to kill the careers of quite a few talented programmers with eXtreme Experience. I've seen this syndrome repeat itself many times through successive programming fads.

      Cheers,

      Jerry Hicks.

    53. Re:Overrated by Anonymous Coward · · Score: 1, Insightful
      Frankly, I can't understand what is so new about this whole pair-programming thing. I mean, haven't you guys *ever* worked on a team? There's no need for your teammate to be staring over your shoulder the entire time, but if you're working on a team, there's constant feedback and communication on how the implementation is coming, how the design should be, heavy mumbling on "why the heck doesn't this compile?!" with the rest of the team all gathering 'round to help out...

      This is team work, it works, everyone can be coding and sharing without having to be actually sitting down in front of the same computer! And if someone is tired or in need of help, he can get up and go to someone else on the team and talk a bit and code a bit and, you know, communicate with the team? Really, you need a shebang-thing like "pair-programming" to realize how to work in a team? So you never did this?!?

      oO

      Strange, strange world...

      Also, when I'm co-piloting (not at the keyboard, that is) I feel this incredible urge to return to my desktop and code something


      That's called "frustration". Or "boredom". Happens a lot when I see someone code :p
    54. Re:Overrated by 1lus10n · · Score: 2, Insightful

      Maybe to managers who dont understand the typical coder they should be an endagered species. To me I look around at corporate software and I am wholly unimpressed. I look at the things that the "overnighters" have accomplished vs the things the guys wearing ties and sitting in cubicles have accomplished and I pick the "overnighters" without any hesitation, flow charts, fancy buzz words or any fluff.

      You'll notice that firms who force crap like XP (but not limited to) onto coders fail in the long term. (or at least from a technical perspective they fail) I can also guarantee that sitting two people down to code on one terminal is a quick way to cut production and ramp up cost in a big way. Even the best minds dont always work well together.

      Software engineering is not the same as coding or testing and people who try to force everything into one role are in for some real shockers. You dont see engineers building the bridge, and you likely never will. The most efficient design is an architect/software engineer who designs the program/application/whatever with some input from the coders and/or testers, the coders then start to build the thing in question with oversight from the architect. Once your at a certain point you then include the testers. In the current corporate culture (which largely fails to understand the technical aspect of things) they try to replace the architect position and force the technical aspect down a level. Which is why you end up with so many project managers who use things like XP.

      --
      "Two things are infinite: the universe and human stupidity; and I'm not sure about the the universe." --Albert Einstein
    55. Re:Overrated by Anonymous Coward · · Score: 0

      That's just a lotta dogma. I've worked in pairing situations, worked solo and had the wonderful privilege of working with a few close-knit teams consisting of 4-5 developers who literally thought "as one".

      Guess which scenario was most "productive" (an elusive term itself)? That's right, the close-knit teams.

      From my experience the thing that causes programmer productivity to suffer the most has been when an organization becomes overly politicized. This often causes a lot of bad decisions to be made, particularly regarding the hiring and placement of team members. Then once a poorly selected team is in place they aren't able to get a straight answer out of the organization about ANYTHING (including program specifications or performance feedback).

      I'd suggest a lot of organizations might do better through introspection than by hopping on the XP bandwagon (which will likely increase the snakepit factor for a lot of places).

    56. Re:Overrated by TheRaven64 · · Score: 1
      I mean, you could argue that it's more efficient to use a for each, but do you really know what's going on under the hood, and whether or not it's just checking the length function anyway.

      In the case of Objective-C, which is the language I use the most, yes I do. I wrote the FOREACH macro that I use, and it does things like caching instance method pointers for efficiency. Since it's a macro, I know I am safe from copy-and-paste errors, which I would not be if I just used an idiom as you suggest.

      For the new version of Objective-C (which includes a for each construct), this is still the case, as I have read the gcc source code for the part which explains how it is implemented (it's horribly ugly, but very efficient) and written an article explaining it.

      How do you know you're at the end of the array unless you check the length?

      If you are not changing the contents of the array, then you only need to check the length once. If checking the length is a trivial operation (e.g. looking up an element in a struct) then this is cheap. If it is a method call, then you may find that a significant fraction of the time spent executing the loop is checking the length of the array.

      I guess you could be checking a variable instead of calling a function, but unless you're going for the ultimate in performance, in which case you'd be better off programming the thing in assembly, then it isn't going to matter.

      You should always provide as much semantic information as possible. This has two uses:

      1. It makes your code more readable, and
      2. It makes it easier for the compiler to insert correct optimisations.
      There are very few situations in which you should be using the idiom you proposed. Most of the time you should use an enumerator, or a map/fold method in the collection object.
      --
      I am TheRaven on Soylent News
    57. Re:Overrated by nschubach · · Score: 1

      If I had code standards that are that specific, I'd have to spend more time sifting the standards than actually coding the program. I, however, prefer the code it now, and make it efficient later technique, so I'm sure my argument is lost on some folks here.

      --
      Every time I start to have faith in humanity, I ruin it by driving to work between 7 and 8 am.
    58. Re:Overrated by LauraW · · Score: 1
      Some of the ideas, such as test-driven development (although this concept is not restricted to XP), work well.

      I agree. TDD takes a bit of time to get used to, but once you're doing it regularly it comes more naturally. Once you have the tests, it can really change your development style. Yesterday I started a fairly huge refactoring of part of our system, and I'd shudder to think what it would be like to do this "without a net" if we didn't have the test coverage.

      Another aspect of XP that I like is the iterative planning, where you have fairly short iterations, empirically determine how many person-days or "points" of work you can get done in each iteration, and use that to plan the project. In my experience it provides a more accurate view of reality than most other planning methods. Of course, you still have to do a good job of breaking down your project into a bunch of small tasks that can be estimated semi-accurately. And this iterative planning isn't unique to XP. Lots of other agile methodologies like Scrum use it.

      Others, such as pair programming just do not work in my opinion. Programmers are solo beasts

      I used to feel this way. When I got put on a pilot XP project in our group a few years ago, the pair programming felt pretty unnatural, and I didn't enjoy it as much as solo programming. Part of that was just because it was new, I think. Also, the XP consultant I usually paired with was very good. I'm no slouch, but he'd been doing XP and pairing for years, had lots more experience developing Web applications than I did, and knew Javascript a lot better (that is to say at all). I was the expert in our company-specific infrastructure like DB persistence, build environment, etc. and a good Java programmer, but I wasn't as fast. And I was a "solo beast" and wasn't as articulate as he was.

      It took some getting used to. I learned a lot, mostly about XP, TDD, and refactoring. But a lot of the time when we were pairing I either like I alternately had to struggle a bit to keep up ("What did you just do?") or just got bored when I wasn't at the keyboard, or I felt really slow and on display when I was driving.

      After that I had a year or two off from doing much pairing and have gotten back to it only recently. I find that I like it a lot more this time around. Recently I took about 6 weeks off from work, and pairing made it much easier to get back into the project when I came back. The pairing also helps when we're working on something tricky in our implementation, or when we think about changing the API of our subsystem. But there are times when pairing doesn't make as much sense, for example when you're just tweaking visual bits of a UI to make the designers happy. There's little point in two people sitting through something tedious like that.

      I have mixed but mostly positive feelings about the rest of XP and Agile. The iterative planning seems to work quite well, at least for medium-term projects like the one I'm working on right now. The only trick is breaking things down into small enough tasks, and in finding all of the tasks early enough that you get a good picture of how long the overall project will take. I mostly like the test-driven development. Sometimes I'll still start changing or adding to the implementation without writing tests first -- when I don't know what I want to do in advance, it can be easier to explore that way. But I won't submit the code without adding tests for the new functionality.

      The one thing I dislike a bit about XP is the lack of too much up-front planning and the attitude that you can refactor your way to the right design. I think that's true to some extent, but not universally. For example, when you're desiging an API that other people are going to use, it pays to do a bit more up-front design. You still won't get it right on the first try, but it can lead to less refactoring and less pain for your clients if they start using the code early on. Performance is also an i

    59. Re:Overrated by jythie · · Score: 1

      - Pairing is fun.

      I actually found it far more tedious and mind-numbingly boring then dedicated code reviews myself.

    60. Re:Overrated by computational+super · · Score: 2, Interesting
      What in the seven hells were you doing before?

      Probably running complete end-to-end regression tests every time he made even a minor code change, as his boss likely required him to do in the name of "efficiency".

      I got my first professional programming job in 1990, back in the days before even the term "methodology" had entered the lexicon. After just a few months, practices like what we now call unit testing and refactoring seemed obvious to me - so obvious, in fact, that I just started doing them. Along comes my boss (who's never tried to so much as launch a text editor - back then, it was common for programmers to have bosses who weren't even terribly comfortable with computers) who asks me what I'm doing. I explain that I'm setting up a program to test the program I'm working on (and making subtle changes to the target program itself so that it can be "unit tested") and he berates me for wasting time. As a beginning programmer, I have no choice but to figure he knows something I don't know, so I abandon what I'm doing. (Actually, I continue to do it in secret, because nobody's proposing any more effective ways to get my job done).

      Fast forward about seven or eight years - Martin Fowler publishes a book called "Refactoring", Kent Beck publishes a book called "Extreme Programming Explained". My boss introduces me to these revolutionary concepts that will change the way I program. Now I can finally begin writing unit tests in the open and admit to it freely! I start to write unit tests and subtly refactor programs so that they can be unit tested... and the programmers around me berate me for disturbing their pristine, pure code (that works just fine, thank you very much!) by removing things like hardcoded file names and IP addresses in the name of some new-fangled, high-falutin "extreme programming" concept. Sigh...

      --
      Proud neuron in the Slashdot hivemind since 2002.
    61. Re:Overrated by ClosedSource · · Score: 1

      "What XP tries to do, with its "whole-shebang" methodology, is to build in safeguards in the process so that neither managers nor programmers can avoid them"

      It's a nice theory, but it doesn't wash. The fact is that under XP companies can still not give you enough time to do all the work, programmers can still avoid writing a good test (even in pairs) etc.

      XP advocates are trying to claim that somehow the rules will be followed in XP, but not anywhere else. I can propose methodology ZP where the rules say you must unit test, perform code reviews etc. Then if people don't follow the rules, I can just say "that's not ZP, because you didn't follow the rules to the letter".

    62. Re:Overrated by Lazerf4rt · · Score: 1

      That is some nerdy shit!

    63. Re:Overrated by 1lus10n · · Score: 1

      A better way of putting this would be what components/sections are writen by individuals. Sure on large projects people collaborate, but thats out of need, not nature.

      --
      "Two things are infinite: the universe and human stupidity; and I'm not sure about the the universe." --Albert Einstein
    64. Re:Overrated by AuMatar · · Score: 1
      Pair programming can be seen as a kind of code review, but with the reviewer in equal position with the programmer. Traditional code reviews tend to be frustrating for the programmers, because the reviewers are in position of authority.


      If you have positions of authority, then you're doing code review wrong. THe correct way is to send a diff to your team, then wait for comments. Formal review processes are slow and don't really bring anything to the table that less formal methods don't.

      But when you put two programmers with equal authority, you have one thinking about the bigger picture and the other reviewing his mind flow. At the same time the later is writing down the ideas in code, with the first one reviewing his code as he types.


      And in practice this brings out the worst of everything in a formal review. You're not only wasting 2 people getting 1 persons job done, but you have constant friction between developers. You have no room for different work habbits (for example, I work best if I can take a 5 minute break every hour or so, can't do that if I have someone over my shoulder). You waste time arguing over minutae. And worst of all- IT DOESN'T FIND BUGS. Pair programmed code tends to be as buggy as regular code. Typically all the pairing does is find a few syntax errors early, which is why we have compilers. YOu're far, far better off with an opening design review followed by a code review when done.
      --
      I still have more fans than freaks. WTF is wrong with you people?
    65. Re:Overrated by AuMatar · · Score: 1

      What percentage are written using solid engineering techniques where people define interfaces and implement subsystem functionality individually? Nearly 100.

      --
      I still have more fans than freaks. WTF is wrong with you people?
    66. Re:Overrated by Cederic · · Score: 1


      >> Programming should be a social event!

      I'm struggling to determine whether your entire post is sarcastic, ironic or sardonic. So I'll skip the rest of it and merely note that you've accidentally said something correct.

      The better I get at software engineering the more apparent it becomes that software creation is a social process.

      (Note that I'm speaking about software development in a business environment. That is, after all, the context in which XP is predominantly used. If you're writing code to solve a specific personal problem then personally I'd recommend you go and visit the chemist instead)

    67. Re:Overrated by Anonymous Coward · · Score: 0

      "The better I get at software engineering the more apparent it becomes that software creation is a social process."

      That's what I like, objective evidence.

    68. Re:Overrated by jafac · · Score: 1

      While I see pair programming's implicit code-review as better than NO code review at all, I believe that a formal review process is explicitly more trustworthy.

      When two coders work very closely together, over time, they tend to accrue the same work habits, the same syntax, the same judgement, etc. This leads to a mini-groupthink mode, that can give both coders the same blind spots. (unless you mix-up the teams occasionally - and normal turnover should keep the larger group well-stocked with fresh people).

      A formal review by a larger group can reveal these blind spots.

      However - the "formal review" also has its flaws; that is, getting a larger group of reviewers to ACTUALLY review the code (rather than sit, yawn, and sign-off) is much more difficult than you'd think. This flaw is almost more dangerous than a single developer with no review at all. There's no consistency to how well a formal review board works, and there's a false sense of security.

      --

      These are my friends, See how they glisten. See this one shine, how he smiles in the light.
    69. Re:Overrated by GileadGreene · · Score: 2, Informative
      Off the top of my head:
      • Structural engineering - static load analysis of simple structures, finite-element modeling of complex structures
      • Digital hardware design - boolean logic, circuit simulation, more recently formal verification via model-checking and higher-order logic
      • Control engineering - frequency methods for stability analysis (PID controllers), linear algebra for the derivation of optimal control laws
      • Spacecraft trajectory design - pretty much all orbit analysis is mathematical in nature, and even the heavily numerical work is rooted in things like dynamical systems theory
      • Communications system engineering - statistical analysis of signals and noise, coding theory to improve SNR
      • Safety critical software - formal proof, model-checking

      Note that most engineering doesn't rely on formal mathematics to ensure correctness - they still do testing as well - but formal mathematical work can significantly increase your confidence in correctness, and it can help to detect design errors much earlier in the design process. Some things simply can't be tested though - spacecraft trajectory design is one of those things where the math must be right, becuse you only get one shot.

      Now, let's flip the question around. Can you give me an example of a field of "real engineering" that doesn't make use of some kind of mathematics to help understand and analyze proposed designs?

    70. Re:Overrated by Anonymous Coward · · Score: 0

      if you lose train of thought that way, why don't you just tell your
      partner so he can wait to you are finished writing.

      Another good idea is for programmer #1 to make the unittest for a function
      then programmer #2 make the function and the unittest for the next function
      and then they switch again.

    71. Re:Overrated by murdocj · · Score: 2, Insightful

      The parent summarizes very well what I find problematic with pair programming. I'm a slower "let me walk thru it" kind of guy. I also sometimes need to just dummy up some throwaway code to see how something works. Having me pair program with a faster, "just do it this way" guy drives me nuts, because I feel like I'm being reduced to a typist.

      I have had successful "pair programming" sessions at my old job, but that was before I even knew what pair programming was. When someone had a tough nut to crack, we'd sit down together and work thru it... maybe we'd type code, maybe we wouldn't. It wasn't a case of one person directing the other person what to do. And once the need to pair up was done and it was clear what to do, we'd split up. Done *as necessary*, pair programming works fine.

    72. Re:Overrated by Anonymous Coward · · Score: 0

      > it's hard to complete the tests much less complete the code before we're asked to change something.

      Use iterations !
      Before each iteration (1-4 weeks) the work for that iteration is planned.
      In the iteration the custommer is not allowed to make changes or interopt the team.
      When the work for the next iteration is planed the custommer is
      free to change all he wants.

      If the custommer insist on changing something under the iteration,
      the tell he that then you will cancel the current iteration then
      plan a new iteration with his changes and then execute it.

      Now, he got his change but he have to wait a full iteration to get it.
      This might make him back down and start planing the change request better.

    73. Re:Overrated by murdocj · · Score: 1
      That's an idealistic view. It would be more accurate to say the code gets committed when the more aggressive developer is happy

      EXACTLY right! Some programmers like to imagine that there "one true way" of doing things. Just look at the posts in this thread. If you are paired up with such a person, you're going to do it their way. I've pretty much gotten to the point where I don't even argue (most of the time), I just try to figure out what they want, and then do it. Sometimes it's better than what I would have done, sometimes it's just different. But having to battle thru code is not a lot of fun.

    74. Re:Overrated by Anonymous Coward · · Score: 0

      > The XP books make very clear that it's either all or nothing.

      They certainly claim that it's all or nothing. Real world experience has shown them to be full of shit. Pair programming, for example, is a a reusable process across virtually any methodology, and while story cards are ok for brainstorming, they're crap for real project management when you actually have to go look a requirement up.

    75. Re:Overrated by CynicalTyler · · Score: 1

      Well I'm not sure if the use of mathematics counts strictly as "formal methods", but software development should be based in mathematical reasoning as well: algorithmic study is math, and so is Big O notation. Both of these are vital to software engineering, if perhaps less than universally practiced. And let's also take a moment to appreciate the fact that just because you're a coder doesn't make you a software engineer. Similarly, I can build a bridge over an irrigation ditch out of two-by-fours and duct tape, but that doesn't make me a civil engineer. The parallel being, a coder and a software engineer may both get the job done but 9 out of 10 times the engineer will do it better, faster, prettier, more reliably, and will yield a product that can be maintained.

    76. Re:Overrated by e2d2 · · Score: 2, Informative

      Actually what you are saying is completely not true when it comes to XP. They clearly say in their docs that you can choose the pieces of the methodology that you feel valuable and leave out ones you don't use.

      It also was extracted from a real world project methodology used by the C3 project. So in fact this methodology came from real world practices, not out of someone's ass as you imply:

      http://www.xprogramming.com/Practices/xpractices.h tm

      I've been in environments where we've used XP, I've been in environments where we used CMM (level 5!), and I've been in environments were we used nothing at all. IMO, most practices of XP are solid and can be used well in the real world. For instance unit testing gained popularity via XP. That's a good thing. Continuous building, something that large projects have been using for years, is a good practice. Etc.

      So why hate? It's good to be skeptical in this industry. But hear the evidence before you judge and when you do judge, justify it with evidence and reasoning. Not just notions of ulterior motives.

    77. Re:Overrated by Anonymous Coward · · Score: 0

      > Like whether a specific for loop should be written as for(i = 0;imyArray.length();i++) or as for(i = 0;i=myArray.length()-1;i++)

      Yeah I know it was just an example, but: you avoid off-by-one errors by not looping the index at all and using actual iterators. foreach, mapcar, iterators, whatever. If you're using C, use a real container type.

      If you think you need the array index, you probably don't, and if you know you definitely do (e.g. you're using the index in another method) you better know how to code around it anyway. Once you pass around numeric indexes into arrays, you've basically invented pointers and all the nastiness that comes with them.

      An interesting thing about Java, I hardly ever see ArrayIndexExceptions these days thanks to the use of real iterators. Now if only they could do something about NullPointerExceptions (SQL has NOT NULL, C++ has stack objects and hard-to-null references .... why the hell not Java?)

    78. Re:Overrated by AuMatar · · Score: 2, Insightful
      - Pairing keeps you completely focussed on a single important task. This benefit alone at least doubles the productivity of every developer and makes pairing cheaper.


      Actually, the least productive time I've ever spent was spent pairing. YOu end up either arguing over everything or shooting the breeze more than coding. I find pairing reduces the productivity by at least 75%- that 1 pair is less productive than either one of the two coding alone.

      - Pairing produces better designs that last longer.


      Good design up front does that. Pairing tends to have little to no effect unless their was no design to begin with. In which case you have bigger issues.

      - Pairing prevents simple mistakes and saves you from loosing time in the debugger.


      Yes, but it does so by costing 100% time of 1 developer. If you spend an hour of simple bug finding for a day of coding, pairing cost 7 hours. And worse, pairing does not eliminate simple bugs- it finds only about half of them.


      - Pairing fosters shared knowledge about the project that is being worked on. It makes it easier to exchange people between tasks.


      There's better ways to do this. Design reviews and code reviews, for example. Which have the advantage of spreading the knowledge to an entire team, not one person.

      - Pairing helps learning. People teach eachother programming techniques, patterns and ways of working with IDEs.


      So do code and design reviews, and they do so with far, far less cost. And IMO, far greater learning value.

      - Pairing helps raising the spirit of the team. It has worked extremely well to glue our team together, although we only see eachother in real life twice a year.


      I've seen higher morale the day of layoffs than when we were pair programming. I have never seen something destroy morale that fast. By the end of the week I was ready to punch my partner in the face, and we started off friends.

      - Pairing activates the speech area of your brain and makes you more creative.


      Wow, now this is utter bullshit.

      - Pairing is fun.


      Here's a list of some things slightly more fun than pairing, you should try them:

      *genital amputation
      *being in a full body cast
      *walking on broken glass

      If I was told I had to pair program again, I'd quit on the spot. I'd move into another industry rather than put up with that bullshit again.
      --
      I still have more fans than freaks. WTF is wrong with you people?
    79. Re:Overrated by Champion3 · · Score: 1

      Three words: No silver bullet.

      --
      I'm going to the casino. Don't gamble.
    80. Re:Overrated by chromatic · · Score: 1
      As with any other method, it assumes all the specs and implementation have been worked out before the code is even written...

      Completely untrue. See Spike Solution, for example.

      its amazing how most new features are always rated as low priority by someone other than the customer....even more amazing about how many 'stories' aren't written by the customer

      It is. What you describe isn't XP. It doesn't surprise me that it didn't work very well.

    81. Re:Overrated by 2short · · Score: 1


      Senior + Senior can be good too, when you need it.

      It definitely depends on the pair. My office mate and I have worked together a long time, and have similar styles. We've found pair programing highly effective when something needs to go out the door very fast and correct. With me looking over his shoulder (he types faster), we can generate complete, shippable code considerably more than twice as fast as either of us working alone. But if we did it all the time, I think we'd go insane.

    82. Re:Overrated by chromatic · · Score: 1
      The better I get at software engineering the more apparent it becomes that software creation is a social process.

      The better I get at creating things, the more apparent it becomes that creation is a social process. How many creative people do you know who work completely alone, with no feedback from anyone, ever?

    83. Re:Overrated by Anonymous Coward · · Score: 0

      1. No company in their right minds wants to pay for TWO programmers to do a single job. But then, again, you can always get 2 programmers at half-price to do the job (and have half the quality of one full price programmer).

      Good thing pair programming isn't about 2 people doing 1 job, then! They're:
      - writing code to do a task (your "single job", I bet)
      - coming up with an appropriate way to do it, that's already been past one set of eyes
      - commenting when necessary, because somebody else is trying to follow
      - training the more-rookie programmer

      If I was running a team, and I had the choice of 2 units of code, or 1 unit of well-designed, well-commented code plus training, I'd go with the latter at least part of the time. The rookies is going to have to maintain it next month, anyway, so why settle for letting the expert code it (without comments, and without training the rookie) or letting the rookie code it (poorly)?

      2. As with any other method, it assumes all the specs and implementation have been worked out before the code is even written....nobody has the freedom to write experimental throwaway code to even see if their approach is even feasible in the coding, or, if programming a device, if the device will even work with the approach being made (for you people not in the embedded world, most device datasheets are incorrect and seldom get corrected).

      I don't know anywhere in the XP Rules or elsewhere that claim this. XP is almost the opposite of Waterfall, which does assume this. IME XP really excels when specs aren't known: it's a bottom-up approach, which is inherently more flexible.

      3. While its great at letting the mundane functions be rewritten (refactored) as many times as possible, it gives a mechanism where newer features are *always* put off (by managers usually) indefinitely....its an illusion, under a few managers, that the programmers will ever get to implement the newer features wanted by customers (its amazing how most new features are always rated as low priority by someone other than the customer....even more amazing about how many 'stories' aren't written by the customer.).

      I'm not sure what you're getting at here. If managers want "a mechanism where newer features are always put off indefinitely", you can find one under any scheme. XP is a way to write programs, not a management panacea. XP is no better or worse at training your managers than any other system.

      4. Even in the XP books it is explained that XP is not meant to work for every single software environment/situation....yet there are managers who will do their best to try to force it to work when it won't.

      And a hash table isn't an appropriate data structure for inverting a matrix. Just because you found a programmer who's writing a matrix inverter with hash tables doesn't mean that hash tables aren't useful data structures.

      No tool is good at everything, and just because you found somebody who's trying to use it where it doesn't work doesn't make it bad.

      I always find it really is better for a group of Programmer Peers to sit down together and review the code AFTER it has been written (with tests). Trouble is, most companies/managers refuse to understand that 'Programming Peers' do not include the stock boy in shipping.

      Again, if your amnagement thinks "the stock boy in shipping" is a peer, you have management issues which XP can't solve. If management made you write all comments in Latin, XP (or any other system) couldn't magically solve that, either, but it's not a failing of XP.

      Just my $.02. Can you tell I didn't really like being under the XP model myself?

      It sounds like you don't like being poorly managed (nobody does!), and are using XP as a whipping boy.

    84. Re:Overrated by Peter+La+Casse · · Score: 1
      ... and changing even a small piece of code often requires changing a lot of tests. If you can offer any suggestions about how to improve that, I'm all ears.

      That's the wrong way round. Shouldn't you be rewriting the tests to conform to the new specifications then changing the code for the re-written tests that fail?

      Yes, that's the XP way, but either way, each change requires you to change lots of tests. The problem is that if you do it the XP way, tests first, then you maximize the number of tests you have to change for each code change. If you code first, you might not have written all your tests yet.

    85. Re:Overrated by Anonymous Coward · · Score: 0

      Junior + senior didn't work for me. I was forced to work with a junior developer on a relatively simple (I could have coded it in 2 days) project. A week and a half later company priorities changed and the work was abandoned. This was driven from our QA department who clearly knew more about coding than I did. Wasted time and wasted money.

    86. Re:Overrated by Anonymous Coward · · Score: 0

      All reliability engineering is ultimately statistical in nature. A formal method can only establish "correctness" of the questions asked of it, which can never be complete.

      As far as software goes, consider Dijkstra's A Discipline of Programming to understand why unit testing, in the right hands, is ultimately equivalent to formal specification.

    87. Re:Overrated by Anml4ixoye · · Score: 2, Insightful

      Some comments:

      1. No company in their right minds wants to pay for TWO programmers to do a single job. But then, again, you can always get 2 programmers at half-price to do the job (and have half the quality of one full price programmer).

      No, companies want to pay for what is going to deliver them the biggest ROI for the least amount of money. They don't care how many people are on a job, as long as they get the profit in the end.

      2. As with any other method, it assumes all the specs and implementation have been worked out before the code is even written....nobody has the freedom to write experimental throwaway code to even see if their approach is even feasible in the coding, or, if programming a device, if the device will even work with the approach being made (for you people not in the embedded world, most device datasheets are incorrect and seldom get corrected).

      We do plenty of spikes, which is exactly throwaway code. We then throw it away, and rewrite it using test-driven development.

      In fact, the whole point of XP is to be in situations where the code and specs are constantly changing, and thrives in those kinds of environments.

      3. While its great at letting the mundane functions be rewritten (refactored) as many times as possible, it gives a mechanism where newer features are *always* put off (by managers usually) indefinitely....its an illusion, under a few managers, that the programmers will ever get to implement the newer features wanted by customers (its amazing how most new features are always rated as low priority by someone other than the customer....even more amazing about how many 'stories' aren't written by the customer.).

      This is definately false. XP is all about the customer driving what the developers are working on by listing what is the highest priority and most value for them. The developers sign up for stories to do just that. Sometimes they don't sign up for the most valuable story - generally because either they need something quick to do, or because it is necessary to complete another story.

      4. Even in the XP books it is explained that XP is not meant to work for every single software environment/situation....yet there are managers who will do their best to try to force it to work when it won't.

      Can't argue with that!

      I always find it really is better for a group of Programmer Peers to sit down together and review the code AFTER it has been written (with tests). Trouble is, most companies/managers refuse to understand that 'Programming Peers' do not include the stock boy in shipping.

      Just my $.02. Can you tell I didn't really like being under the XP model myself?

      It sounds like you were under a very poorly implemented model. In fact, I can't believe they would call that XP - because it sounds almost as far from it as you could be.

    88. Re:Overrated by GileadGreene · · Score: 1

      I suppose it depends on what you mean by "formal methods". I know that some people think using UML is using "formal methods". I also know that some people think that using "formal methods" means using some kind of heavyweight "formal" process with rigidly defined steps, lots of documentation, and many "formal" reviews. But in my book (and in Wikipedia) "formal methods" are

      ...mathematically based techniques for the specification, development and verification of software and hardware systems.
      So yes, algorithmic study and Big O estimates are one part of using "formal methods" for software design.

      The point is that there is a lot more to the use of mathematical reasoning in software than just Big O estimates. You can utilize strong type systems to statically guarantee useful properties of your code (up to and including freedom from deadlock in the case of TyPiCal's type system). You can make use of Hoare logic to reason about state changes - this is the basis for developing useful assert statements. You can use design-by-contract and logical assertions to define and statically check the specifications on your code (see for example SPARK/Ada or JML). You can use process algebra, or temporal logic, or Petri nets, or some other mathematical technique, to model and understand multi-threaded and distributed systems, and analyze them for deadlock, livelock, and various other properties. I could go on. The point is, there're lots of useful mathematical tools for reasoning about software. Some of them have been integrated into current programming practice (type systems, assertions, pre- and post-conditions), others are still a long way from gaining acceptance (formal proofs with Z or VDM, concurrency design using process algebra). The most important thing is to know what tools are available, and be willing to apply them when and where they might be helpful.

    89. Re:Overrated by mpaque · · Score: 1

      I found pair programming to be very efficient.

      Absolutely! One huge benefit that's often overlooked is that pair programming lets the manager assign two programmers to a single cubicle, sharing one desk and computer system. The savings in facilities costs alone can be breathtaking!

      When combined with an office space scheme such as Microsoft's Workplace Advantage, which can be reconfigured in minutes to meet rapidly changing staffing and project requirements, square footage and power use per employee is reduced, and management oversight becomes much easier. Combined with the self-monitoring nature of pair programming, productivity rises, and the savvy level 68 partner will find themselves well rewarded.

    90. Re:Overrated by matfud · · Score: 1

      I have to agree.

      I've just spent the last two weeks refactoring a piece of code. It bored me senseless. I could not imagine how it would have felt for someone looking over my shoulder. Wooo. Two whole weeks of stareing at someone using an IDE to push exceptions through to all interfaces, delegates and implementations of those methods affected by each and every change. Great use of time that would be.

      However I also know that code reviews (after the fact) start to fail when a code change is large (as with the rafactoring mentioned above). Nobody can read the code changes for a large body of work and KNOW that they will work. There are just too many assumptions in the code, and too large a scope for anybody to be able to understand the new code. They most definately cannot judge it for correctness (which they possibly could using pair programming). At this point code reviews tend to degrade to analysis of specific problems but do not provide any real help with respect to overall functionality of the code. Code reviews (after the fact) can ensure that the correct "appraoch" was taken and that specifics of the code were correct but that only happens if the reviewer has intimate knowlege of the code being chaneged.

      I'm not really sure what my point is.

      The only thing I know is that all processes fail at some point. In software engineering that point (failure of process) occurs far to often for comfort.

      matfud

    91. Re:Overrated by SteeldrivingJon · · Score: 1

      When combined with an office space scheme such as Microsoft's Workplace Advantage, which can be reconfigured in minutes to meet rapidly changing staffing and project requirements, square footage and power use per employee is reduced, and management oversight becomes much easier.

      Mike, now you've gone and spilled the beans about the upcoming product, Microsoft Prisoner's Dilemma (tm) which will show you how to maximize productivity by covertly pitting each member of a pair programming team against the other.

      --
      September 2011: Looking for Cocoa/iOS work in Boston area Cocoa Programmer Quincy, MA
    92. Re:Overrated by dubl-u · · Score: 1

      It works for me. Indeed, from your comments, I'm not sure that what people told you was Extreme Programming was what I would call Extreme Programming, so it's not shocking we'd have pretty different opinions.

      No company in their right minds wants to pay for TWO programmers to do a single job.

      Any company in their right minds wants to get the best results. I'm vastly more productive while pairing. Why? As they say, "Two heads are better than one." The hard part in programming isn't the typing, it's the thinking. Pairing gives me third-draft code in first-draft time.

      For the last full XP project I did, we paired all the time and ended up with as much test code as production code. But comparing with the metrics in McConnell's Rapid Development we were in the top 10% in terms of production-code productivity. And after 36 developer-months of work, we had a total of two bugs in production, both quickly fixed.

      As with any other method, it assumes all the specs and implementation have been worked out before the code is even written.

      That's entirely incorrect, and makes me think that whatever you were doing, it wasn't Extreme Programming. Go read one of the books on Test-Driven Development (like the one from Beck) to see how it should actually work.

      The project I mention above was a startup, where we had very little worked out in advance, and where requirements changed weekly as we got new data from market or user research, as competitors got up to new things, or as people had great new ideas. In a typical environment, the developers would have killed the suits, as we never would have gotten to finish anything. As it was, we had a great relationship. Every week they'd pick the most important things to do and we'd do 'em, figuring out the requirements as needed. I loved it. All of the devs have gone on to become big XP advocates, as none of us have ever had things go so well.

      nobody has the freedom to write experimental throwaway code to even see if their approach is even feasible in the coding, or, if programming a device, if the device will even work with the approach being made (for you people not in the embedded world, most device datasheets are incorrect and seldom get corrected).

      Are you serious? When you don't know that something is feasable, XP teams do throwaway code as research. Often they do what are known as "spikes", which are simple end-to-end proofs of concept. You write just enough to prove that the approach is reasonable, then toss it out and do real development. And the heart of XP is short release cycles and heavy testing, so you validate in the real environment as often as possible.

      I don't do much embedded work, but there are plenty of XP teams that do. I know of one that does medical devices and another that does machine vision systems for manufacturing. The devs in both companies love it.

      While its great at letting the mundane functions be rewritten (refactored) as many times as possible, it gives a mechanism where newer features are *always* put off (by managers usually) indefinitely....its an illusion, under a few managers, that the programmers will ever get to implement the newer features wanted by customers (its amazing how most new features are always rated as low priority by someone other than the customer....even more amazing about how many 'stories' aren't written by the customer.).

      If your managers are picking the wrong things to do, that's not a problem that XP can solve; no process is proof against putting idiots in charge. But the typical XP project is supposed to do new work every week, and it's supposed to do the things with the highest business value first. Refactoring should never show up in the feature list; only things of customer value are supposed to be scheduled in the work queue, and refactoring takes place as needed to acommodate new work.

      Even in the XP books it is explained that XP is not meant to work for every single software environment/situation....yet there

    93. Re:Overrated by dubl-u · · Score: 1

      But real engineering requires planning and clear interface definitions, and XP -- almost to the point of being pathological -- attempts to avoid planning as much as possible by subsitituting endless chatter and tremendous time wasting repeatedly reimplementing what could have been done right the first time.

      From the stats on my projects, doing it XP-style is not a waste of time, and is in fact very efficient. Why? Because XP postpones design work until the last responsible moment. That sounds crazy until you realize that the beginning of the project is when you will know the very least, and the end is when you know the most. That's true about everything on the project: the domain, the requirements, the people involved, the technologies used, everything. The best decisions are the ones with the most information, and therefore the latest ones.

      For things that can be done perfectly the first time, maybe XP isn't the right process. But a project where I learned absolutely nothing the whole way through would be terribly dull, so I'd never work on one of those anyhow.

    94. Re:Overrated by dubl-u · · Score: 1
      Whenever I have someone watching me, and they point out the mistakes, telling me to go and correct something, I often lose my train of thought.

      This is a typical novice problem, but doesn't happen much with experience pair programmers. Navigators learn to shut up about missing semicolons and such, or at least to wait until they're sure you've missed it. And drivers learn to talk more about what they're doing. And since good pairing involves the keyboard changing hands often, everybody talks more so that the pair is heading in the same direction generally.

      It definitely takes work to learn, but having had experience both ways, I now really miss pairing when I'm working solo. And I'm not the only one. Compare these two blog posts:
    95. Re:Overrated by dubl-u · · Score: 1

      You'll notice that firms who force crap like XP (but not limited to) onto coders fail in the long term. (or at least from a technical perspective they fail) I can also guarantee that sitting two people down to code on one terminal is a quick way to cut production and ramp up cost in a big way. Even the best minds dont always work well together.

      You have any data to back that up? My project stats and the studies on pair programming show the opposite.

    96. Re:Overrated by BiggerIsBetter · · Score: 1

      Arguably, though, "software engineering" isn't real engineering until you use formal methods to ensure the correctness of your design and implementation.

      That's exactly what I'm arguing. I think XP has a place in improving quality, but I don't think you can call it Engineering. Take pair-programming for example, and you've got two craftsmen making experienced choices and catching each others mistakes, not the application of formal methods with their correctness based on scientific principals. It's a big difference IMO.

      --
      Forget thrust, drag, lift and weight. Airplanes fly because of money.
    97. Re:Overrated by Anonymous Coward · · Score: 0

      I hear all these points a lot, but I have noticed a curious thing about people doing pair programming. They seem to substitute pair programming for actual collaboration. Instead of getting up and going to ask other about some part of a large system, they "explore the code" and waste hours. It is kinda sad watching people who should know better, but they are fooled into this pair thing instead of a true team thing.

    98. Re:Overrated by chromatic · · Score: 1
      I could not imagine how it would have felt for someone looking over my shoulder.

      I cannot imagine what that sentence has to do with pair programming.

    99. Re:Overrated by matfud · · Score: 1

      Does pair programming not involve 2 people? Or do you just not pair programming when the task is boring? Or is refactoring not thought to be programming?

      It would take about 2 mins to describe the goal of the refactoring. It took two weeks to do it.
      There was no creativity involved just lots of button pushing to tell an IDE what to move where. A
      second person could not contribute (unless they could use a seperate machine). Therefore they would
        have nothing to do but "peer over my shoulder" for two weeks (while of course being completely amazed
      at my ability to push buttons rapidly and the pretty effects that appearing and disapearing popups have).

    100. Re:Overrated by chromatic · · Score: 1
      A second person could not contribute (unless they could use a seperate machine).

      That's why it's not pair programming. You might as well get a life-sized cardboard cutout of William Shatner and put him behind your chair for all of the good it will do you.

      Pair programming is a discussion between two programmers about how to solve a problem. Incidentally, it produces tests and code that solve the problem and conform to the team's agreed coding standards. Someone watching you type is very different; it's just someone watching you type.

    101. Re:Overrated by 1lus10n · · Score: 1

      I can certainly get you some links if you wish. Before I go to that length bear in mind that even HUGE advocates of pair programming admit that its an "idealist" solution that in many circumstances has a less than ideal situation/environment. Bear in mind the following problems:

      1. Location. In todays workforce we are becoming more and more spread out. I have worked with hundreds (no exageration) of people all over the world, most of whom I have never met. Most companies wont pay relocation. That leaves a shallow talent/personality pool. XP doesnt work well over distances, in those cases its essentially no different than most (well run)corporate environments.
      2. Time. It assumes that whatever pair you currently have working together is going to work the same hours, take the same breaks and so on. VERY rare. Most people who get into a decent job do not expect to be doing things like factory workers. Why would a good coder subject themselves to someone elses life requirements, when they can get a job elsewhere ?
      3. Personalities. Most programmers are not outgoing. Its a fact. That makes them very difficult to work with in this type of situation. A good percent of those who are outgoing are control freaks who "must do it their way". I have personally witnessed the hell that occurs when management puts "teams" together to do this sort of thing. More often than not a bussiness would have to "re-hire" everyone to make sure they are suited for this type of work. Given that a good chunk of them will not be, that leads to turnover which is a cost. Bussiness's hate costs.
      4. Infrastructure. Most companies do not have adequate desk space/office space/conference rooms to do something like this. Not to mention, some people are just not comfortable working that close (physically) with someone else.

      I think from an idealist or an educational standpoint its a great concept, and can probably be implemented with amazing results. However in my experience with the huge corporate environment I can say this wont work most of the time. For many reasons, not the least of which are highlighted above.

      --
      "Two things are infinite: the universe and human stupidity; and I'm not sure about the the universe." --Albert Einstein
    102. Re:Overrated by demallien2 · · Score: 1

      I feel for you. I haven't yet found a good answer to the problem, but I have a few partial answers... And of course, the idea of running without tests just horrifies me these days. Anyway, here are are few things that I have found helped for the "changing test" dilemma

      1) In my team we try to make any test-case specifiable in XML. We than write tools to convert the XML to the real binary data needed for the test cases. Making changes in a handful of XML files, or in the tool that does the conversion is relatively trivial compared to rewriting raw data by hand

      2) The execution of the tool itself is handled by a script, so that all test cases are regenerated when the generation tool changes

      3) Scripting languages are your friend. In the unhappy case where you have to change more than a handful of XML files to accomodate, a quick script in Perl, Ruby, Python, or whatever scripting language rings your bells, to make the changes automatically will generally be less painful than doing it by hand (and more fun). As a bonus, as you do this several times, you start to discover certain scripts that are very useful generally, that can be put together to generate another tool to manage the tests.

      Anyway, that's how we handle changes to the requirements that demand a rebuilding of lots of test cases...

      Has anyone found any other useful tricks to deal with this?

    103. Re:Overrated by demallien2 · · Score: 1

      I can't help feeling that you have never actually tried XP, have you?

      #1 If you need the spec before hand, it's not XP. XP only needs the spec for that which is to be delivered in the next build - ie in the next week. It does not need a spec for the whole shebang

      #2 XP is about delivering new features ALL OF THE TIME. If you are just refactoring code without delivering new features, it isn't XP

      #3 If you don't know if a particular technique is goping to work (like in your example with problems with chip data sheets), XP has a specific mecanism for dealing with the problem, called a spike. You bash out some throwaway code that does nothing but verifies that something (an API, a chip, a comms system, whatever) works the way that you need it to work

      #4 Pair programming produces higher quality code that is easier to refactor when requirements change (as they will). Paying two programmers to produce higher quality code than that which would be produced by one programmer is always a good option. Not to mention that difficult problems that may block a single programmer can often be resolved by two programmers quite rapidly. I know from experience that sometimes it may take me a day to find the right abstraction, when having a second programmer next to me would have enabled us to find a solution in maybe a couple of hours.

      Anyway, from what you have described, you have never actually worken under an XP paradigm. you should give it a try sometime. It's highly rewarding, and highly effective

    104. Re:Overrated by QuestorTapes · · Score: 1

      I apolologize in advance for any offense; that's not my intent.

      > 1. No company in their right minds wants to pay for TWO programmers
      > to do a single job.

      True; but if a company has paid 20 programmers to do the work of onten (sub-par) programmers for some time, they can be convinced.

      > 2. As with any other method, it assumes all the specs and implementation
      > have been worked out before the code is even written....

      That sounds like BUFD, not XP; have I misinterpreted your meaning?

      > nobody has the freedom to write experimental throwaway code to even see if
      > their approach is even feasible in the coding,

      Sure they do; I've done it hundreds of times for -very- grateful managers. They'd much rather I test an idea with cheap throwaway code than try to implement an expensive, untested idea we can't afford to change later. They'd prefer to find out without even a few hours of coding, but sometimes that isn't possible.

      Device comments snipped; I don't program devices.

      > 3. While its great at letting the mundane functions be rewritten (refactored)
      > as many times as possible, it gives a mechanism where newer features are
      > *always* put off (by managers usually) indefinitely....its an illusion,
      > under a few managers, that the programmers will ever get to implement
      > the newer features wanted by customers

      Sure doesn't sound like XP to me; sounds like you bought "Dr. Quack's new and improved miracle elixer - now fortified with XP from the healing waters of Casablanca. Guaranteed to cure what ails you or double your ailments back!"

      > I always find it really is better for a group of Programmer Peers to
      > sit down together and review the code AFTER it has been written (with
      > tests). Trouble is, most companies/managers refuse to understand that
      > 'Programming Peers' do not include the stock boy in shipping.

      So, let me get this straight; you did something someone called XP...but apparently wasn't. It didn't work, and you find good old code reviews work better...except you aren't actually getting to do peer code reviews either.

      To paraphrase G. K. Chesterton, "XP has not been tried and found wanting; it has been found politically difficult to implement, and left untried."

      Anyone else have a different take?

  4. buzzwords by arun_s · · Score: 1

    agile approaches, agile software development in project management movement, open and honest communications
    So what's this about, apart from the management-speak?
    I feel like I read half dozen pages with barely any content.

    --
    I can explain it for you, but I can't understand it for you.
    1. Re:buzzwords by aadvancedGIR · · Score: 1

      agile software development is simply a way to say "code now, we'll get you the specs later"

    2. Re:buzzwords by TechnoBunny · · Score: 2, Insightful

      But thats not necessarily a problem - how many projects are based around the same requirements as they were when the first line of code was written? Of course, in an ideal world they would be. But the world isnt ideal. Far better to start work accepting that the code you write may well be thrown away at some point, and continually refactoring to keep on track towards the changing target.

    3. Re:buzzwords by darkchubs · · Score: 1

      web 2.0 user contributed content revolution started in 2005 with myspace Ajax Because DHTML was too hard to say if you were bound and gaged in the trunk of a mobster, and managed to get to a cell phone.

    4. Re:buzzwords by Anml4ixoye · · Score: 4, Insightful

      I view XP as a methodology to solve a major problem I've seen in software - communication.

      Why do we build software? It's to provide value for our customer, whether that customer be a marketing department, a gamer, or ourselves. And if we don't keep in touch with what it is that they want (recognizing that people generally don't know what they want until they see it), we probably won't provide the value we could.

      To that end, XP encourages constant communication by using frequent releases of the stories (read: features) the customer thinks are most valuable. The customer gets a working version every week, or month, or 2 months, or whatever cycle seems to work for the team.

      From the development side, XP encourages the code to always be potentially shippable by having a suite of Unit and Acceptance tests (the former written by the developer /before/ the code is written, the latter written by the customer(!)). We continually run them using a Continuous Integration server which monitors the code repository and checks out the latest version, notifying the team of any conflicts.

      It also encourages things like Collective Ownership, where, in theory, any developer can sit down and work on any part of the system. This is achieved partly through the unit test suite, and partly through pair programming with frequent swapping (we swap pairs generally twice a day, in the morning and at lunch, but some teams do more, and some do less).

      But, regardless of all the practices (and there's more than I'm listing above), the end goal is /not/ to be "XP", it's to deliver value to the customer. And if your current practices are doing that, then that's what is important.

      As far as TDD, I have a series I recently did which shows how TDD works here (part 1) and here (part 2).

    5. Re:buzzwords by Ignignot · · Score: 1

      Seems like a lot of that is just rehashing the same old same old. What's wrong with the programming surgical team described in the mythical man month? Collective ownership seems to be deliberately creating more communication overhead for programmers. In other words, what does XP bring to the table that is useful instead of just different?

      --
      I submitted this story last night, and it didn't get posted.
    6. Re:buzzwords by ClosedSource · · Score: 1

      As any old married couple can tell you, being in the same room doesn't guarantee communication.

    7. Re:buzzwords by E++99 · · Score: 1

      As explained in my forthcoming manifesto on "Double-Super-Extreme Programming", every time you hear or use a buzzword, a part of your brain dies forever. Under my theory, you also realease frequently to the client, except that you release "deliverables" instead of "stories". Aside from making sense, it looks a lot more justifiable on an invoice. As far as "pair programming", DSXP calls it "cluster coding", and outlaws it under penalty of death. Instead you just program the entire system in the same "programming language", and hire programmers who are all proficient in that language. The result is that, in theory, any programmer can sit down and work on any part of the system. To further that end, technical documentation is added. But hey, if "XP" increases the value you deliver to the customer, more power to you!

    8. Re:buzzwords by Cederic · · Score: 1


      You haven't done much software development in large enterprises have you.

      >> you release "deliverables" instead of "stories"

      or follow XP properly, and release "working software". Which adds "business value". Is this so hard a concept?

      >> The result is that, in theory, any programmer can sit down and work on any part of the system.

      That is so naive. In theory, what works in theory will work in practice. In practice...

    9. Re:buzzwords by dubl-u · · Score: 1

      agile software development is simply a way to say "code now, we'll get you the specs later"

      That's almost right. Instead, it's "Start the project now, and we'll get you the specs as you need them." I will never spend entire meetings arguing over the precise meeting of section 5.2.3.1.5 pargraph 4 in a 500-page spec again. I will never again spend months overdiscussing possible future projects without writing any code. I am pleased as fucking punch.

      Instead, every week we pick the things we're going to do off a stack of index cards. We talk about them in front of a whiteboard until the devs feel like we have enough to go write code. Then when I realize I need more info or want to show something for feedback I look up at a product manager and maybe wave one hand to get his attention. Bada-boom, question answered, and I'm back to coding. Before we declare any unit of work done we get the product managers to sign off that it's done. On Friday, we present the new version of the program to all who care to see it, and maybe we release it, too. On Monday, we start again.

      I love it.

    10. Re:buzzwords by dubl-u · · Score: 1
      What's wrong with the programming surgical team described in the mythical man month? Collective ownership seems to be deliberately creating more communication overhead for programmers. In other words, what does XP bring to the table that is useful instead of just different?

      To my mind, several things:
      • On a surgical team, it's only the surgeon who has much fun. Ask people who actually work in surgery; the stereotypical surgeon is an annoying prima donna.
      • Surgery does not happen without the surgeon; on teams with collective ownership, people can take vacations as needed.
      • Collective-ownership teams maximize use of individual skills. On a day when there's a DB-releated issue the database maven takes the lead. When it's system performance, the former sysadmin steps up.
      • Collective-ownership teams are more flexible; they can work as one unified team or several smaller ones depending on workload.
      • Your truck factor is much better.
      • The overhead is very small if, as XP recommends, you are pairing and change your pair partner every few hours.

      Of course, perhaps there are surgical-style teams that do better than the ones I've experienced. But for me, I love the collective ownership.
  5. Re:"XP makes improvement possible" by arun_s · · Score: 1

    *skims article*

    XP blah blah trust blah improvement blah Embrace blah

    *kicks in knee-jerk anti-M$ flame*

    --
    I can explain it for you, but I can't understand it for you.
  6. Unfortunate name by Timberwolf0122 · · Score: 1, Funny
    Its principles of transparency, trust and accountability


    I find this funny as the programming behind Windows XP relate to none of these.
    --
    In the not too distant future, next Sunday A.D.
    1. Re:Unfortunate name by Anonymous Coward · · Score: 0
      Its principles of transparency, trust and accountability


      I find this funny as the programming behind Windows XP relate to none of these.

      I wish windows did have transparency....
  7. XP = Extreme PR by gjuk · · Score: 1

    Thank goodness Slashdot's there to help publicise not only ground breaking new books, but even new editions. I really wouldn't want to miss the opportunity to discover why I need to buy book v2.0.
    Does anyone remember when Slashdot wasn't quite so heavily infected by the insideous PR virus?

    1. Re:XP = Extreme PR by blowdart · · Score: 1

      And what else would you expect from someone who writes a book on the topic, a neutral point of view where both good and bad points are discussed and taken on board? No, that would be too useful for a technical news site, instead lets recycle old PR puffery.

  8. Laundry? by LaughingCoder · · Score: 3, Funny
    FTA:
    I think that the first book was in reaction to a culture for programmers that was basically camping in their cubicles in Silicon Valley where people were spending their entire lives living out of cubicles with food brought in and laundry taken out.
    There are places where they take out laundry? Real programmers don't change their clothes until the job's done!
    --
    The more you regulate a company, the worse its products become.
    1. Re:Laundry? by chawly · · Score: 1

      Showers ? With soap?

      --
      How many beans make five, anyhow ? ... Charles Walmsley
    2. Re:Laundry? by E++99 · · Score: 1

      Showers, Laundry, Soap (and possibly even SOAP) -- ALL unnecessary. In my new development model, which this article has inspired me to formalize and publish (called Double-Super-Extreme Programming), I will include schematics for how to build a forced-air ozone machine out of an old vacuum cleaner, a high-voltage neon sign transformer, a pyrex guitar slide, and a small amount of aluminum screening. (A computer interface for controlling the duty-cycle programmatically is left as an exercise for the reader.) When the output tube is directed up a pant-leg, all foul-smelling bacteria, fungus, and algae cells that may chance to accumulate on the body or clothes are killed instantly by the ozone. Since air-borne ozone only penetrates liquid with difficulty, the ambient temperature is recommended to be kept below 65F to prevent sweating. If using ozone to eliminate mouth-borne bacteria, one should seal the glottis to prevent entry of ozone into the lungs. (Asthmatics are encouraged to avoid this method altogether)

    3. Re:Laundry? by Skapare · · Score: 1

      Real programmers can change their clothes. They just keep on typing while they are doing it.

      Seriously, when I was in high school, a friend of mine successfully changed out of his band uniform (he had been at dress practice before our little road trip) and into his street clothes, while driving his car on the highway. And yes, he did become a programmer.

      --
      now we need to go OSS in diesel cars
    4. Re:Laundry? by Herkum01 · · Score: 1

      Real programmers don't change their clothes until the job's done!

      You have other clothes to change into? Freak!

  9. Why is it called "Extreme"? by 10Ghz · · Score: 4, Funny

    To me, the word "extreme" sounds like they program in assembly 24x7 for one week straight, or they program with laptops, while running away from a pack of wolves or something. But apparently it's not like that. So what makes it so "extreme"? Did they come up with that name when they were discussing their interests with their jock-friends?

    "Oh yeah, I'm in to pretty extreme things. Currently I'm doing base-jumping and ultimate-fighting. How about you?"
    "Well.... uh.... I'm in to.... EXTREME programming"
    "Whoa! Radical!"

    --
    Lesbian Nazi Hookers Abducted by UFOs and Forced Into Weight Loss Programs - -all next week on Town Talk.
    1. Re:Why is it called "Extreme"? by aadvancedGIR · · Score: 1

      Sure, the name is some PR trick, but it makes sense because this technique is a reaction to all those new trendy development process in which (when you push them to the extreme) you are spending 90% of your time in meetings or drawing graphs and then the code is supposed to magically write itself and work perfectly on the first build because this technique is so well conceived.

    2. Re:Why is it called "Extreme"? by Anonymous+Codger · · Score: 4, Funny

      It's called Extreme because they take some basically good ideas and push them to such extremes as to be completely useless in the real world.

      --
      No sig? Sigh...
    3. Re:Why is it called "Extreme"? by kfg · · Score: 1

      Buzzification. If it had been "invented" a bit earlier it would have been called "Turbo" programming.

      KFG

    4. Re:Why is it called "Extreme"? by Eivind+Eklund · · Score: 1
      And in other news, you are commenting on things you haven't tried in the real world, right?

      Because I can't believe anybody can conclude, after having tried XP, that it is completely useless in the real world in all cases. There are cases where it is a good fit - many cases - and there are some where it is a bad fit, but after having taken the risk of actually testing it, it's clear that it is tremendously useful in the right context.

      --
      Doubting the existence of evolution is like doubting the existence of China: It just shows that you're uninformed.
    5. Re:Why is it called "Extreme"? by Eivind+Eklund · · Score: 1
      The name comes from introducing some good practices and then doing them extremely ("Turning them up to 11", in the words of Kent Beck).
      • "Don't let your programmers be tired" -> "Forbid programmers from working overtime".
      • "Do code review" -> "Do code review in real time, by pair programming"
      • "Test" -> "Test everything, immedately, by not writing code until you have a failing test"
      • "Get customer feedback" -> "Release in very short cycles, and have a customer owner that decide how things should work"
      • "Don't overcomplicate the code" -> "Delete all code and functionality we do not need today, and clean up all dirty code immediately"


      Eivind.
      --
      Doubting the existence of evolution is like doubting the existence of China: It just shows that you're uninformed.
    6. Re:Why is it called "Extreme"? by Anonymous Coward · · Score: 2, Funny
      You have some misspellings there... let me correct you:

      • "Don't let your programmers be tired" -> "Forbid programmers from working overtime at your own peril as you should realize that a programmer is a real, live adult human being which happens to be a professional and therefore can take care of his own work hours due to the fact that he has been living with himself for quite a few years and knows perfectly well when he's tired and when he's not, and resents being treated like a child by a moronic idiot who just happens to have stepped on enough people to raise up the ladder enough to annoy said programmer".
         
      • "Get customer feedback" -> "Release in very short cycles, and have a customer owner that decide how things should work in your dreams, because in the real world you should realize that your customer doesn't give a s***t about whether you need feedback or not, because he's already told you everything you need in all those prep meetings and impromptu emails, and just wants to sit back and click on the darned button and see things working, so he won't be looking or testing anything you send to him because "it's not done yet" until he thinks "it's done" and then he'll change all those lovely specs you spent some much time tuning the tests to fit into. And your manager will be so desperate to please him that he will say yes to anything he says, because after all, this is Extreme Programming, it's great, it's flexible, we can do anything as long as the tests come out alright, right?"


      There, cleaned that up a bit for you.

      JARCP
      ----
      Just Another Random Cynic Programmer
    7. Re:Why is it called "Extreme"? by Bozdune · · Score: 1

      Right. The top-down specification fanatic (the opposite of the XP advocate) secretly believes that if his spec is tight enough, the code really will "magically write itself." He lives in a fantasy world, of course, because his spec will not survive its first user experience.

      With XP, the pendulum has swung rather "extremely" in the other direction. Unfortunately, most customers don't know what they want, and don't know how to tell you, even if they had time to sit with you (which they typically don't). Showing them interim versions of complex software will scare the living crap out of them.

      XP does well in a rapid prototyping environment and on simple applications (like most Web apps), where the feedback is immediate and the discussion isn't about deep concepts or functions, but rather about UI issues like "where would you like this button" or "should this be one screen or two screens."

    8. Re:Why is it called "Extreme"? by AuMatar · · Score: 1

      I've done it. I think its completely useless in all real world cases.

      --
      I still have more fans than freaks. WTF is wrong with you people?
    9. Re:Why is it called "Extreme"? by swillden · · Score: 1

      I've done it. I think its completely useless in all real world cases.

      So you've done it in all real world cases, or at least a statistically valid sample?

      I've never used XP, and I'm skeptical of some elements, but I'm even more skeptical of such absolutist claims as yours.

      --
      Note to ACs: I usually delete AC replies without reading them. If you want to talk to me, log in.
    10. Re:Why is it called "Extreme"? by kchrist · · Score: 1

      I've used XP and have determined that it is completely useless in all real world cases. That's why I bought a Mac.

      Wait, what were we talking about again?

    11. Re:Why is it called "Extreme"? by Anonymous Coward · · Score: 0

      I have, and the dude's right

    12. Re:Why is it called "Extreme"? by Eivind+Eklund · · Score: 1
      Interesting. Could you elaborate what issues you have had with it, which parts didn't work out for you?

      I've never done what might be termed "complete XP", though I've adapted as many elements of it as has been possible to push into the situations I've been in (pair programming, test first, cut down time, minimize planning, estimation habits ++), and that's worked very well. I've got reason to believe the rest of the practices support this (from 20+ years of experience with programming projects), but I've not tested them all together.

      Eivind.

      --
      Doubting the existence of evolution is like doubting the existence of China: It just shows that you're uninformed.
  10. One of the best quotes ever... by chuckplayer · · Score: 4, Insightful

    Kent Beck hits the proverbial nail on the head with this zinger (which I'm sure is certain to stir up quite a few):

    "It's not all about programming. It's not all about programmers. Programmers aren't somehow special and to be protected and coddled. I used to say often that programmers were children. They liked not to be yelled at and to have more toys ... I think programmers are, or at least can be, adults and can and should, for the good of development and themselves, act that way."

    The above quote sums up almost every problem that I have seen over the past 10 years with the various development shops I've been a part of.

    1. Re:One of the best quotes ever... by ClosedSource · · Score: 1

      Since Ken Beck isn't really a programmer it isn't surprising.

    2. Re:One of the best quotes ever... by jeti · · Score: 1

      Does this imply that managers like to be yelled at and aren't interested in new toys?

  11. Not Extreme by pryonic · · Score: 1

    If it doesn't involve fire or razorblades it's not extreme. I hate the way the word has lost it's meaning these days...

    --
    Never underestimate the power of stupid people in large groups.
    1. Re:Not Extreme by CynicalTyler · · Score: 1
      If it doesn't involve fire or razorblades it's not extreme.
      Man... I'm glad I'm not pair programming with this guy!
  12. Never... by Thrip · · Score: 1

    Xtreme Programming: Never have so many invested so much on a proposition backed by so little evidence.

    --
    I'm awake! The answer is BONK!
  13. Real Extreme Programming by niceone · · Score: 5, Funny

    IMO real extreme programming should involve at least 3 of the following:

    1. Only having 24 hours to deliver the code
    2. Failing would cause thousands of innocent people to die
    3. Getting your interface specs from a dieing man after being helicoptered across town
    4. Using emacs
    5. Failing code review results in you and/or your spouse being shot in the leg
    1. Re:Real Extreme Programming by raduf · · Score: 1

      3. Getting your interface specs from a dieing man after being helicoptered across town

      Omg! This one is scary!

    2. Re:Real Extreme Programming by mqj · · Score: 1

      6. Program an application using an XOR-linked-list.

    3. Re:Real Extreme Programming by aug24 · · Score: 1

      ...and just when you're creeping up on a bad bug, your phone goes "bep-bep bip-burrrr" and the bug overhears and runs away and you have to chase it. Am I over-stretching the analogy yet?

      --
      You're only jealous cos the little penguins are talking to me.
    4. Re:Real Extreme Programming by settrans · · Score: 2, Funny

      5. Failing code review results in you and/or your spouse being shot in the leg

      I'm confused. Are we still talking about programmers?

      --
      "When I wake up in the morning I piss cryptographic excellence." - Bruce Schneier
    5. Re:Real Extreme Programming by E++99 · · Score: 1
      XOR-linked-list.
      SWEEEEEEET! One day I WILL find a good reason why I need to use that.
    6. Re:Real Extreme Programming by Anonymous Coward · · Score: 0
      5. Failing code review results in you and/or your spouse being shot in the leg
      That's not extreme, thats groovy baby!
    7. Re:Real Extreme Programming by Pastis · · Score: 1

      And extreme hacking is the famous Swordfish movie scene:

      1 minute to crack a site, half-drunk, a lady under the table talking to your microphone, with a gun pointed to your head.

    8. Re:Real Extreme Programming by Stickney · · Score: 1

      Actaully....being a programmer in the US Army Signal Corps has been much like #1, 2, and 3....

      --
      ...the right of the people to keep and bear arms, shall not be infringed.
  14. Re:"XP makes improvement possible" by Anonymous Coward · · Score: 0

    When are slashdotters going to figure out that eXtreme Programming (sometimes called XP) has nothing at all to do with Windows XP? They happen to share a two-letter abbreviation, but that's it.
    XP != Windows.

  15. Congratulations ! by Anonymous Coward · · Score: 0

    You just found out what the "extreme" in "extreme programming" refers to.

  16. Yeah? One word: by dpiven · · Score: 1

    IRAQ.

    1. Re:Yeah? One word: by Thrip · · Score: 1

      I stand corrected.

      --
      I'm awake! The answer is BONK!
  17. This article is rubbish by s31523 · · Score: 1

    Although I am a proponent of some XP concepts and feel certain concepts can help with software quality and delivery time, this article does not highlight any of them. This article is nothing more than "blah blah blah, XP is great, now go and buy my book". How on earth did the editors let this one in.

  18. Write the test first by Rik+Sweeney · · Score: 1

    I don't understand this. You write the test before you write the code? This doesn't work in real life because, as every experienced coder will know, the goal posts get shifted at the last moment, usually a week before the product's supposed to go live.

    1. Re:Write the test first by s31523 · · Score: 1

      Yes, one of the ideas is to drive the development of a product through tests that are written first. The one concept missing is that this can't be the only testing since theses tests are mostly low-level, i.e. at the module/class level.

      Here is a real example. I work in aerospace, and my responsible area is navigation. We use INS's as the base latitude/longitude for position estimation. We have 3 of them, for redundancy purposes. We have a heirarchy of rules which decide which INS will drive the navigation solution. My spec tells me that the selected INS chosen goes 1, 3, 2 and that the criteria for selecting is not failed and not in align mode. So I write a test which allows me to create an API/class like, INS.getState(), INS.setState (state) and Nav.GetSelectedIRS. I stub these out, and use them in a test, say:
      LeftINS : INS;
      RightINS : INS;
      CenterINS : INS;
      SelectedINS: INS;

      LeftINS.setState(Failed);
      RightINS.setState(Navigating);
      CenterINS.setState(Failed);

      SelectedIRS = Nav.GetSelectedIRS();

      if SelectedIRS != RightINS {
      TestFailure ("Wrong INS Selected");
      }
      else
      {
      TestPassed;
      }


      Now, I make it so this test fails, and it is up to the developer to respond to this test by making it pass. We don't have daily software builds, we have daily software test runs. Intuitively, it seems like more work, but it really isn't; you just do work out of order and it seems like you are doing more of it, when you do less work because you find more problems early on in the cycle. The above example is simple, but it is one of the first tests. Later, you expand the test to integrate more API and or classes, say the classes that status the sensors and declare their state. There is some work in setting up an environment like this, but it is worth it. Plus, you know when you are "done"; when all the tests pass, you are done. The tests can be written with higher level classes and be more tightly coupled to specs or requirements, and if written right can take the place of requirements thus reducing the amount of muda.

    2. Re:Write the test first by Tony+Hoyle · · Score: 1

      In my experience the goalposts move as you write the code... 'oh, that's possible? then can you also do this, and it would be nice if a widget popped up here, and...'

      Writing the tests first means you're going to be forever updating them as the specs change.

    3. Re:Write the test first by aurelianito · · Score: 1

      Well, you write the test 15 minutes before the code. So the goal post is quite fixed.
      And, because you go live every coupple of weeks, and you have all the tests written before, it's easier to change the code to acomodate to the new requirements. If a test that is not suposed to break breaks, you know that there is some problem with what you did. This safety net allows you to program faster and simpler.

    4. Re:Write the test first by TechnoBunny · · Score: 1

      But if the requirements change, and you update your code, then you're going to have to test it anyway to ensure that it meets the updated requirements, so there's no extra overhead to rewrite the tests first.

    5. Re:Write the test first by Aladrin · · Score: 1

      As opposed to writing them just after you code something, and the specs change anyhow? What's it matter if you code the test before or after the actual code, if the specs change -after- you've done both?

      One big idea from test-first is to keep you coding things that actually matter, instead of adding stuff 'I'll need later' and then never do. There's also the obvious benefit of having tests to cover everything.

      --
      "If you make people think they're thinking, they'll love you; But if you really make them think, they'll hate you." - DM
    6. Re:Write the test first by sh4na · · Score: 1

      Automated testing is not enough to ensure that your software implements and can handle the specs. Automated testing only ensures your modular calls at a low level return what you expect, but a complex software is so much more than simple modular calls. A complex system is much more than the sum of it's parts, which is why unit testing cannot mirror the system's complexity, therefore cannot test it all.

      Going about writing tests ahead of code is all fine and dandy, but that way you miss the big picture, the interaction between the parts, because you are concentrating on details. If you can combine the detail view with a bigger view, fine, but most people can't, especially in tight schedules. You end up doing everything in detail view and building your system so tight everytime you get a spec change you hack it because it's not flexible enough, and it grows up to be a nice collection of hacks that performs well under unit testing because, really, that's what it was designed to do.

      That's what I've seen happening in the real world, unfortunately. Theory is a very nice thing, but it kinda tends to depend on being perfectly implemented, with perfect people and perfect timings and perfect managers and perfect clients.

      --
      shana
      ......gone crazy, back soon, leave message
    7. Re:Write the test first by Chanc_Gorkon · · Score: 1

      Horseshit. Writing to pass the test which was written first is absolute horseshit. First, writing JUST a test script is utter nonsense. The only true way to test these things is to have a USER test it. So frigging what if the test passes....if the user doesn't like the arrangement of the controls or the color of them then you have to change it....yeah, it's crap, but trust me...I would rather NOT have 400 different colors (if you let them change this on their own) to look at when I go to try to fix something for someone when something runs amok (sometimes users pick the most eye bleeding colors....). Yes, those are minor things but the fact is the USER is the one who picks them. A computer program can't test that the color is eye pleasing. A computer program also cannot test every single scenario that a user can come up with. One thing I have learned is NEVER underestimate the idiotic things users can come up with.

      --

      Gorkman

    8. Re:Write the test first by backwardMechanic · · Score: 1

      Isn't that the point? You discover some clever new trick you'd like to include. Okay, write a test (i.e. specify exactly what you're trying to achieve), write the code, enjoy. But most importantly, your fancy new widget mustn't break any of the previous tests. Maybe the new feature is important enough that some of the earlier tests need modifying, but that's a decision you need to talk about and actively decide. Otherwise you end up shooting for your own goal...

    9. Re:Write the test first by DanCentury · · Score: 1

      Where I work we're supposed to write a test plan with the client's assistance right after the business requirements are baselined. We write our Unit Test plans before we start the high level design and programming.

      I don't like it, but it seems to eliminate feature creep by virtue of the process.

    10. Re:Write the test first by ClosedSource · · Score: 1

      Even if you write the test after the code, you still have the test around to rerun, so writing the test first offers no advanage there.

    11. Re:Write the test first by ClosedSource · · Score: 1

      One of the reasons that many methodologists miss this point is that they typically have experience only in simple business applications. Rarely do they have any real-world experience in multi-threaded, multi-process, or real-time systems.

    12. Re:Write the test first by Alpha830RulZ · · Score: 1

      Actually it works just fine. I think that the 'develop the test first' concept is probably the most powerful concept in XP, of which I am at best only a mild proponent. Forcing test development to the front of the process accomplishes several positive things:

      1) it forces you to think about exactly what the data is going to be, and how it's coming to you, before you type a line of code. This usually reveals scads of unthought about issues, most of which are usually resolvable.

      2) It forces the customer/product manager to commit to a design choice, before you invest in it. Sure, the customer can change his mind, and often does, but now it's completely visible to the customer that it's his fault that [the schedule moves out|the cost moves up|another feature doesn't get built].

      3) The assembled suite of automated tests provides a strong start on having a regression test suite that can continually smoke test the product/system. This is just huge for keeping the system stable as you build it. Among other things, it gives you a visbile metric of what breaks when, as you put it, someone moves the goalposts the week before delivery.

      I don't think XP is the solution for everything. I look at it as an assembly of best practices, wrapped up in a book. Personally, I think you can use any of the pieces of XP to good effect without drinking the whole glass of Koolaid, and have done so professionally since 2000 or so, when Beck first started promoting it. I am not a fan of pair programming - I haven't seen the productivity gain from the practice that is claimed, and I find that a lot of devs dislike it. We want to write stuff ourselves, damn it!

      Short iteration development cycles can work really well on some systems, but don't mean much when you are developing something that is a huge edifice, like a utility billing system. On these larger systems, trying to manage coordinating a bunch of short cycle projects inside a larger project can be just too much work, and project management cost as a proportion of the project cost just gets too high. But that doesn't invalidate the value of short iterations, or iterative development, it is just an observation that one size does not fit all. (Do I get points for stating the obvious here?)

      Finally, on 40 hour weeks, I think Beck is just smoking dope, and I wish he would share. There is nothing holy about 40 hour weeks, and every really interesting project I've ever done had periods when 8 hours just wasn't enough to get the day's work done. I realize and agree that people burn out if you work them too hard. However, there are people, projects and times when the team is fully energized while working 12 hours a day for weeks on end. I don't recommend planning to do this, and a bunch of sissies will whine when it happens to them, but really interesting projects, in my experience, tend to not be well behaved with regards to the calendar. I'd rather work 60 hours a week on something neat, than go home after my 40 on yet another XP extension to the accounting module.

      --
      I was taught to respect my elders. The trouble is, it's getting harder and harder to find some.
    13. Re:Write the test first by Cederic · · Score: 1


      The tests being discussed are not end-user testing. They are code level unit testing.

      It doesn't really matter what colour the UI is if the code underneath it doesn't work. And I can demonstrate in under a second that it works because I have 96% code coverage in my unit tests, which include testing edge cases, error conditions, multiple paths and even that the code does what it's meant to do.

      More importantly, TDD (test driven development) is not (just) about testing. The tests are a very important facet, and add tremendous value, but I'd follow TDD even if I threw away the tests afterwards (not that I would, who would turn down a fully automated regression test suite?). That's because TDD gives me better code.

      Better design, better decoupling, better coherence, fewer bugs, reduced duplication. All for free.

      Of course, once I've written my tests, and my code that passes them, I also then let the users test them. As you say, programmer testing is no replacement for functional tests, UAT, performance testing, etc. It will make all of those go considerably quicker and easier and smoother, but that's just my personal observation.

      Sorry, tell me again, why don't you want your code to work?

    14. Re:Write the test first by Cederic · · Score: 1


      My understanding of XP is that it does not preclude, prevent or deride functional testing, UAT, performance testing or any other traditional test techniques.

      Going live every two weeks also means that you don't have to wait long for any bug fixes.

      My experience of XP is that the TDD and Pair Programming between them do reduce the bug count to negligible proportions. It took so long to find a bug that it was quicker to release the software and successfully use it for a few months; fixing the bug took days from "found" to "new release deployed". And that was for a multithreaded system using TCP/IP, database access and unix named pipes.

      If you did want to slow down the releases to production though, your XP release could be a release to your test teams. Ideally you have someone writing automatic functional tests in conjunction with the development, so most testing is pressing a single button, but the developers can keep adding value just as fast as the testers can validate it.

      I don't have experience with real-time systems, but I've been involved in the full project lifecycle for IT developments across multiple systems, in very heterogeneous environments, with frankly daft timescales (thanks Marketing team) and delivered them on time with very low bug counts. The only thing stopping XP working in such environments are organisational issues, team structures, seating plans, availability of the business and commitment from IT.

      My current company doesn't use XP. It couldn't, the organisational barriers are too great. That doesn't invalidate XP, it merely highlights issues with my current company. But we're making progress on those.

    15. Re:Write the test first by ClosedSource · · Score: 1

      Please explain in detail how TDD insures better code? And please, don't just list unproven claims (e.g. "better design, better decoupling..").

    16. Re:Write the test first by Cederic · · Score: 3, Insightful


      Hmm. For the definitive description, I can only suggest you acquire (beg, borrow, buy, etc) a copy of Test Driven Development by (eek) Kent Beck.

      My brief summary:
      You write a test. To write the test you must know what it is you are testing. This means you have to think about interface, so you can access the functionality, and function, so you know what it's meant to do.

      Thus before you've written any code you're already putting a lot of thought into what's going on with your code. Far more thought than most programmers put in (trust me, I've worked with too many ;)

      To be able to write a test with small enough scope (so you don't end up testing half the system - you may want to do that, but not right now) you need to be able to isolate the piece of code you're testing. There are multiple mechanisms to achieve this (see the paper "Endo-Testing: Unit Testing with Mock Objects" for an example) but the outcome is this: The code you write, to pass your test, can be isolated from the rest of the codebase. It is inherently decoupled (at least to a degree).

      Now extrapolate this across the entire codebase. It's all decoupled. It has to be, so that you can test it all in isolation.

      That makes the code easier to re-use too. If a block of code isn't tightly coupled to the things that use it, or to the things it uses, it's easier to re-use with other things.

      Which leads to the other aspect of TDD: Eliminate duplication. If you're doing TDD by the book, you ruthlessly excise any duplication in your code. Where you see two blocks of code doing the same thing you refactor them into one block of code.

      This is relatively risk-free, because all the code you're changing has a full suite of automated unit tests. Which you're running every few minutes (because they take a couple of seconds to run). So you're getting pretty prompt feedback on any errors you accidentally introduce while changing the code.

      Of course, you have a lot of test cases now. These are a form of documentation. They provide examples of how to use your code, and also pretty definitive indications of how it's expected to work.

      So the process of writing tests forces you to write testable code. I believe testable code shares many characteristics with well designed code.

      You may also want to pick up Michael Feather's book on "Working Effectively with Legacy Code". Many of his techniques revolve around building test cases, and refactoring the code to make it more testable. That's not coincidence (and remember - refactoring means "improving the design of existing code").

      As I said, I'm an amateur at explaining this compared to Beck, so find a copy of his book and read through it - it's actually not a long read, the basics really are simple.

    17. Re:Write the test first by ClosedSource · · Score: 1

      "Thus before you've written any code you're already putting a lot of thought into what's going on with your code."

      You describe what developers should do when designing, but there's nothing that forces them to do it just as in more traditional methods.

      "The code you write, to pass your test, can be isolated from the rest of the codebase. It is inherently decoupled (at least to a degree)."

      Modular code concepts have been around for 25 years, same for unit testing. Nothing new here.

      "Which leads to the other aspect of TDD: Eliminate duplication. If you're doing TDD by the book, you ruthlessly excise any duplication in your code. Where you see two blocks of code doing the same thing you refactor them into one block of code"

      I'm not sure if that's technically part of TDD or just part of a broader methodology like XP. In any case, this principle also goes back to structured techniques of the 70's.

    18. Re:Write the test first by Cederic · · Score: 1


      Absolutely. None of this is new. Nobody is pretending that this is new.

      What is new is trying to get people to do it methodically, all the time, without exception, without excuses.

      Although TDD doesn't explicitly force modular design, it very strongly encourages it. Writing tests is much much easier for well designed code, and so the lazy programmer designs well to ease their testing.

      All good programmers are lazy.

    19. Re:Write the test first by Anonymous Coward · · Score: 0

      The tests are not the goal posts, though. The tests are, well, tests.

      Suppose you were writing a calculator program. If you knew it had to do rational numbers, you'd have tests to make sure rational arithmetic worked, and an implementation of rational numbers that passed that test.

      Sure, the customer would come change things 10 times next week, but if you have a solid test for the core functionality, it's easier to shift high-level things around to meet those goals. (If the customer changed what data and functions your program operates on the day before release, you're screwed no matter what. But that rarely happens; once you have a library that makes the expected functionality easy, shuffling it around to do something else is also easy.)

      In a sense, by requiring passing unit tests first, you force the design to be bottom-up, which (as many others have found) gives you more flexibility later on. It lets you meet high-level requirements ("goal posts") much more easily.

      It's hard for me to imagine a program whose entire purpose was so poorly specified that you couldn't write unit tests first. It'd essentially have to be "OK, we want you to write a program, and we don't know what data it'll operate on, or how it will manipulate that data -- start now!"

    20. Re:Write the test first by radishfarmer · · Score: 1

      I will give one (not exaustive) example of TDD giving better code:

      Interface vs. Implementation

      Writing a test to a non-existent module requires the definition of an interfaces for client code to call. The question foremost in my mind is "How ill this be used?". Writing the implementation first risks focusing on the implementation in favour of the interface. I start thinking, how do I make this work? In mature systems, callers often outweigh implementations by several orders of magnitude. So interfaces often matter more than implementations.

      Geniuses who produce perfect interfaces as a consequence of their masterful implementations may not care. But I find it much easier to clean up a bad implementation 18 months later than fix 782 callers that fight with a clumsy interface.

    21. Re:Write the test first by ClosedSource · · Score: 1

      "What is new is trying to get people to do it methodically, all the time, without exception, without excuses."

      This is common to all methodologies. There's nothing in XP that is more likely to get individuals to follow the rules than there is in any other approach.

    22. Re:Write the test first by ClosedSource · · Score: 1

      I'd say that interfaces rarely matter as much as implementations. The current fad these days is to write modules as if the whole world is going to start using them any day now. Don't hold your breath.

      In any case, the fact that you think about interfaces first doesn't necessarily mean you'll create better ones. You could just as easily argue that a programmer thinks "Gee, I've got to write this unit test before I can write any code, so I'll just throw something together".

    23. Re:Write the test first by Chanc_Gorkon · · Score: 1

      Yes I understand the working code. That isn't the issue. It should work before the users get it. That much is obvious. In my book, end user testing has brought out more then any test suite can. Users can spot things MUCH easier then a computer program can.

      --

      Gorkman

    24. Re:Write the test first by dubl-u · · Score: 1

      This is common to all methodologies. There's nothing in XP that is more likely to get individuals to follow the rules than there is in any other approach.

      That's a reasonable thing to think, but it's incorrect. In fact, it's the thing that makes XP different from almost any other method.

      Pairing is one obvious thing: for a pair to slack requires a conspiracy rather than an accident or a moment of weakeness. Common code ownership is a second: if you are working as a team and truly share the code base, you will have plenty of incentive to get your colleagues to do things right. Retrospectives are another; if the team continuously adjusts the process to improve things and be useful, people are more likely to follow it. And short iteration and frequent releases keep people honest by exposing the work often to managerial evaluation and real-world conditions.

      Basically, XP closes and tightens a lot of feedback loops that get left open or are too long in other processes. This gives you the incentive to do great work.

    25. Re:Write the test first by Yakman · · Score: 1

      Unless I've missed the joke, that's a terrible test. Shouldn't the test cover every combination of failed/working/navigating and make sure the right INS is selected in each case?

      If not, then I'm never flying again, incase your code is in my airliner :)

    26. Re:Write the test first by ClosedSource · · Score: 1

      If you look back at this thread, what we are really talking about is the alleged benefits of TDD (swithing to a more broad statement about XP in this thread was my error, you were just responding to what I wrote) which really isn't about pair programming.

      "Pairing is one obvious thing: for a pair to slack requires a conspiracy rather than an accident or a moment of weakeness."

      As far as the idea of paired programming as a way to keep programmers in line is concerned, that goal could probably be acheived without using up an extra programmer. Without a lot of training a clerical worker could probably insure that unit tests were written first, etc.

      "Common code ownership is a second: if you are working as a team and truly share the code base, you will have plenty of incentive to get your colleagues to do things right."

      As has been noted by others in this discussion, the "incentive to get colleagues to do things 'right'" can be a source of irritation and inefficency. Some programmers have the same traits as retired ladies that sit on their porch looking for tiny infractions of the homeowner association rules.

    27. Re:Write the test first by dubl-u · · Score: 1

      If you look back at this thread, what we are really talking about is the alleged benefits of TDD

      Got it. Sorry for the confusion.

      As far as the idea of paired programming as a way to keep programmers in line is concerned, that goal could probably be acheived without using up an extra programmer. Without a lot of training a clerical worker could probably insure that unit tests were written first, etc.

      This is true, but it would miss about 90% of the value in pairing. Pairing isn't a way to keep programmers in line. It's a way to do good work. A clerical worker can't give me good design feedback, or point out a missing edge case in the tests, or nab the keyboard and press forward when I'm stuck. They sure can't sure show me the way they did it on another project, a way I've never seen before. And a clerical worker can't give the feeling of team effort. The best they can do is nag, which I expect would grow quickly tiresome.

      As has been noted by others in this discussion, the "incentive to get colleagues to do things 'right'" can be a source of irritation and inefficency. Some programmers have the same traits as retired ladies that sit on their porch looking for tiny infractions of the homeowner association rules.

      It's possible that some programmers are congenitally unsuited to working on teams. But in my experience, a close team environment helps people more quickly learn the right balance between fussiness and getting things done. And a short-cycle iterative process lowers the stakes. We solved a lot of problems by saying, "Well, that's an interesting point. Let's try it the easy way for a couple of weeks and see how it goes." If the persnickety person was right, we'd all say so. If not, they'd learn that the thing they were worried about wasn't such a big deal. Either way, we all won.

    28. Re:Write the test first by dubl-u · · Score: 1

      If you look back at this thread, what we are really talking about is the alleged benefits of TDD.

      Oh, and responding to what I now think to be your actual point, TDD itself also makes people more likely to test and test well. Why? From my experience, I see three reasons:

      The first is a psychological one. If you write the test first and then make it pass, it feels good. If you're doing TDD properly, your day is a series of small wins, with occasional setbacks. Because you have the safety net of tests, the setbacks are generally small, so your frustration level is low. This is much, much more pleasant than writing tests afterward.

      The second is the that you can't unlearn something. Once you have written the code, you already have a number of notions and assumptions about the problem. For me at least this makes it harder to come at the problem with the fresh perspective that lets me cover all the interesting angles in my tests.

      The third is that after-the-fact testing can feel kinda pointless. I already think the code works, so the best case is that the tests don't tell me anything. Or, worse, they tell me that I screwed up at some point in the past and now need to rework things. Either way, it's dispiriting.

      One of the things that XP and TDD types talk about is being "test infected". Once hooked on TDD, people very rarely go back. Whereas with with post-construction testing, it's usually something that people think they should do, or started to do but gave up. I don't know that I have ever me an engineer who has a substantial system with coverage like I'm used to, which is a 1:1 ratio between test and production code and upwards of 95% measured test coverage. I'm sure they must exist, but the only people I know who code like that are all on XP teams.

    29. Re:Write the test first by Cederic · · Score: 1

      I'm responsible for systems that talk to other systems. The users _are_ other systems. Some of them are over 30 years old.

      Of course, some of the systems do have users. Internal and over the web.

      I'd far rather test my own code than rely exclusively on error messages from a 30yo system to tell me what's not working as expected.

      Since I can test my own code, and still use the feedback from other systems, and users, and system testers, I see no real downside. My users don't either; they get far higher quality code from the outset.

    30. Re:Write the test first by ClosedSource · · Score: 1

      I was responding within the context of your claim that paired programming is an aspect of XP that makes you more likely to follow the rules. I wasn't suggesting that was the only value it had, although I think it's value is outweighed by it's cost.

    31. Re:Write the test first by ClosedSource · · Score: 1

      "If you write the test first and then make it pass, it feels good. If you're doing TDD properly, your day is a series of small wins, with occasional setbacks. Because you have the safety net of tests, the setbacks are generally small, so your frustration level is low. This is much, much more pleasant than writing tests afterward"

      I think this is really a personal statement of how you feel about it, but like any personal opinion, it doesn't necessarily apply to other peoplle.

      "The second is the that you can't unlearn something. Once you have written the code, you already have a number of notions and assumptions about the problem. For me at least this makes it harder to come at the problem with the fresh perspective that lets me cover all the interesting angles in my tests"

      One must have a number of "notions and assumptions" about the problem before you can write the code or the unit test. I don't think this is a problem.

      "The third is that after-the-fact testing can feel kinda pointless. I already think the code works, so the best case is that the tests don't tell me anything. Or, worse, they tell me that I screwed up at some point in the past and now need to rework things. Either way, it's dispiriting."

      Again, that's how you feel about it. What I find pointless is rewriting unit tests again and again to follow the rules when writing the unit test once is just as effective.

      "Whereas with with post-construction testing, it's usually something that people think they should do, or started to do but gave up."

      Just as those managing a TDD project can require that tests be written before code, the manager of a non-TDD project can require unit test for all modules before check-in. Why is it always assumed that some magical transformation of management occurs when an agile process is used?

      I think all of these arguments are rather weak. They're all based on an unproven theory of how people are supposed to think, act, and feel.

    32. Re:Write the test first by s31523 · · Score: 1

      Yes, we test all unique combinations (Which can be measured via a MCDC structual coverage analysis). It was an example of one test input/condition out of the set. Actually, the conditions that drive the expected result are a little more complicated than provided.

      The point is, however, that the actual implementation code was not written first. The test was written first, which essentially builds the implementation API from the perspective of the tester, who hopefully is driving a test via a requirement of some kind. One of the effects of this is clean, cohesive API's which makes for a nice architecture. Anyone who has done time in the test realm usually becomes more consciousness of the API for modules and ends up being a better software architect.

      So yes, the test was not a great test as illustrated, but perhaps you missed the point? Or just busting my balls, which is fine too! :)

    33. Re:Write the test first by dubl-u · · Score: 1

      I think all of these arguments are rather weak. They're all based on an unproven theory of how people are supposed to think, act, and feel.

      Well, they're actually based on my discussions with dozens of people who have done TDD. I agree I don't have scientific proof. But I don't feel any obligation to get some, any more than I need scientific proof of the value of object orientation, clear naming, preferring simple designs over complex ones, or the particular knot I use tying my shoes. I do what works for me, and I'm telling you why I think it works. If you want scientific proof before trying out any new technique, that's your issue, not mine.

      Just as those managing a TDD project can require that tests be written before code, the manager of a non-TDD project can require unit test for all modules before check-in.

      A manager can't require TDD. It's impossible to enforce unless you sit there round the clock, and good managers don't get so much in the business of professionals anyhow. All the people I know who do TDD do it because in their opinion as professionals it's the best way to get work done.

      What I find pointless is rewriting unit tests again and again to follow the rules when writing the unit test once is just as effective.

      So you've tried it both ways for a few months and concluded that one is just as effective as the other? In which case, that's great. You should carry on doing what works best for you. No scientific evidence needed, right?

      On the other hand, if you haven't given TDD a serious try, your conclusion above is just a theory. Which you're welcome to; if you're happy doing what you're doing, then carry on ignoring TDD. I'm always looking for ways to boost my skills, but I'm sure that's not true for everybody.

    34. Re:Write the test first by ClosedSource · · Score: 1

      "But I don't feel any obligation to get some, any more than I need scientific proof of the value of object orientation, clear naming, preferring simple designs over complex ones, or the particular knot I use tying my shoes"

      There's a big difference between having a theory about aspects of code and having a theory based on human behavior. If there's as much evidence that Agile methods are better than there is for object orientation or simple designs I certainly haven't heard about it.

      I think it's rather begging the question and insulting to say "I'm always looking for ways to boost my skills, but I'm sure that's not true for everybody."

      If methodolgies were typically optional on a person-by-person basis, I'd have no problem with them, but that's almost never the case. So I'm not arguing against people doing what works for them, I arguing for the right to do things the way that works best for me.

      If there's solid, non-anecdotal evidence that a new methodology is better, I'll adopt it. Otherwise, I'll do it my own way when I'm allowed to.

    35. Re:Write the test first by dubl-u · · Score: 1

      There's a big difference between having a theory about aspects of code and having a theory based on human behavior. If there's as much evidence that Agile methods are better than there is for object orientation or simple designs I certainly haven't heard about it.

      Hmmm, I guess I missed the double-blind studies on object orientation. And I don't see the big difference; in both cases I'm saying what works for me and why. You may use that information or not. It looks like not, which is fine by me.

      If methodolgies were typically optional on a person-by-person basis, I'd have no problem with them, but that's almost never the case. So I'm not arguing against people doing what works for them, I arguing for the right to do things the way that works best for me.

      Hmmm... I guess I'm not seeing how that's possible. If you're working with other people, then you need to agree on some sort of way of working together. I think if you're working solo, you should certainly have the right to do work the way you see fit. And I think a team also has the right to do work the way they see fit.

      If there's solid, non-anecdotal evidence that a new methodology is better, I'll adopt it. Otherwise, I'll do it my own way when I'm allowed to.

      Could you point me to the solid, non-anecdotal evidence you based your previous methodology choices on? I'd be fascinated to see it.

    36. Re:Write the test first by ClosedSource · · Score: 1

      "Hmmm, I guess I missed the double-blind studies on object orientation."

      You missed the point. The value of object orientation can be derived by studying systems, human behavior cannot. Of course, I recognize that not everybody believes that objection orientation is the ultimate approach, so your invocation of it isn't as effective as you might imagine.

      "Hmmm... I guess I'm not seeing how that's possible. If you're working with other people, then you need to agree on some sort of way of working together.... And I think a team also has the right to do work the way they see fit."

      Sure there has to be a way to work together as a team, but if you do TDD and I test after coding, that isn't problem unless we want to make it one. In any case, "the team" rarely decides what methodogy is going to be used, it's usually dictated by management or pushed by the team's most anal member. In my 20+ years of experience I've never heard management say "The team is going to vote on what methodology to use".

      "Could you point me to the solid, non-anecdotal evidence you based your previous methodology choices on? I'd be fascinated to see it."

      There's a long-standing principle of debate that says that he who wants to propose a change has the burden of proof. In any case, I'm not pushing any methodology in particular. The problem with methodologies is that they attempt to replace judgement that takes place with all the facts at hand with a judgement that takes place with none of the facts at hand. Those creating a methodology don't know anything about your project, your team, your company, your business, your budget etc.

    37. Re:Write the test first by dubl-u · · Score: 1

      There's a long-standing principle of debate that says that he who wants to propose a change has the burden of proof.

      Great. If I ever propose a change, I'll keep that in mind. As far as I recall in this discussion, I'm telling you what works for me and why I think it works. You have questions, let me know.

      In my 20+ years of experience I've never heard management say "The team is going to vote on what methodology to use".

      I guess if you've never had good managers that treat your team like professionals, it's no wonder you're suspicious about methodologies. Me, I'm used to employers telling me what they want done and getting out of the way, so to me it's all just things I might try.

    38. Re:Write the test first by ClosedSource · · Score: 1

      "Great. If I ever propose a change, I'll keep that in mind."

      So you've never suggested to anyone that they should change to XP or TDD?

      "I guess if you've never had good managers that treat your team like professionals, it's no wonder you're suspicious about methodologies"

      I see. You want to ignore my argument against methodologies and pretend that it's all about bad managers.

      "Me, I'm used to employers telling me what they want done and getting out of the way, so to me it's all just things I might try."

      Given that you said this as a response to my comment about a vote on methodologies, I suspect that you've never participated in one either or you would have mentioned it.

  19. Looks like Standard Concept..... however by hcob$ · · Score: 1

    It looks like it's had the curse of consultants beat it down with their theory and "improvements"

    --
    Cliff Claven
    K.E.G. Party Chairman
    Founding Leader of: Koncerned for Egalitarin Governance
  20. XP vs XO by BlindRobin · · Score: 1

    Personaly I miss the days of eXtreme Obfuscation, when multi-year projects, even entire careers, could be made of producing and deciphering intentionally and inadvertantly obfuscated code. Especially when you really had to dig through 4 foot high stacks of 14 7/8 x 11 green bar source listings and associated core dumps just to figure out that some asshole was relocating buffers on a vector just to fsck with the person coming along behind him.

  21. Point out major successes by Oligonicella · · Score: 1

    Perhaps XP should point out a few outstanding successes instead of perpetual promising of improvement. So far, in my experience, the net result is pretty abysmal performance and several extreme failures.

  22. Stop the X! by GNUALMAFUERTE · · Score: 1

    This eXtreme-whatever fashion really has to end. It's just the new buzzword, but it has been way to far this time. Everything from candy and books to programming and movies are X.

    We don't need EXTREME things, why don't you try with creative, different, innovative things?
    People lives such boring lifes, and they have been buying shit for so many years that all the usual lies used to sell are not longer valid, so we have to go the the limits, THIS time there really is something new!. Bullshit.

    All this stuff is the Paulo Coelho of Programming. Bullshit literature for those not manly enough to just code C/C++/Perl/Python/PHP. This are real languages, and they have all we need. But we are in the reign of Coelho's bullshit books; and so, something being just good is not enough anymore. It has to be different to everything else in every way possible, it needs shinny mirrors all over it, and it needs to be easy, it must "change your life", and "take you to new levels".

    I'm tired of this world, that's why i don't live in it.

    --
    WTF am I doing replying to an AC at 5 A.M on a Friday night?
    1. Re:Stop the X! by Res3000 · · Score: 1

      iP? iProgramming?

  23. Good marketing by ClosedSource · · Score: 2, Insightful

    "The XP books make very clear that it's either all or nothing. They don't claim that pair programming by itself is always useful, they just claim that this whole set of techniques taken together is useful. If you're going to do all the other things XP says, XP says you should combine it with pair programming."

    This is just good marketing. By making this "all or nothing" claim, XP has a built-in excuse that you are invoking here. Ever noticed that you hear the phrase "because you're not doing it right" more often with XP than with other approaches?

    1. Re:Good marketing by chromatic · · Score: 1
      Ever noticed that you hear the phrase "because you're not doing it right" more often with XP than with other approaches?

      If I told you how to bake a chocolate cake and you came back in a week, saying "That recipe sucks because I just ate the three cups of flour and it tasted AWFUL?", I'd probably squawk too.

    2. Re:Good marketing by ClosedSource · · Score: 1

      A better analogy for XP would be for you to give me not a specific recipe for cake, but rather instructions on a baking process that includes rules such as:

      Taste the cake before you bake it.
      Make sure you have another cook working with you.
      Change the shape of the cake constantly.

  24. Is he a manager ? by aepervius · · Score: 3, Insightful

    Because all the programmer I know around are quite adult, responsible, and do not care for the latest toy. But they do care that they are given enough time to implement features, taht the features are correctly documented, that the spec are there etc... And in the last 6 years I was there, those point were not met, and usually the manager were responsible for a reason or another, but never beared the responsability.

    To sum up, to define the programmer as "child", is really disapparging, and far far away from reality of the average software developpement shop. Most are average guys which want to do a correct job, but are put in impossible situation by management.

    No if the quote would be applied to manager "manager are like child, they like to play and win, but do not wish any responsasbility in tehir action".

    --
    C. Sagan : A demon haunted world:
    http://www.amazon.com/gp/product/0345409469/
    visit randi.org
    1. Re:Is he a manager ? by chuckplayer · · Score: 1

      I'm not a manager and have no desire to be one. Either you've been lucky or I've been unlucky because I could hardly say "all" of the programmers I've worked with have been "adult".

      I wrote that "almost all" problems were caused by immature (childish) behaviour. Maybe what I've seen hasn't been "childish", but it's far from "adult". Perhaps "an utter lack of time management skills and an unwillingness to put forth any real effort to learn anything" would be better. The managers I've had to deal with were over-promoted programmers exhibiting the same lack of "adult" behaviour that they did prior to their stint in management. Becoming a manager didn't cause their woeful inadequacy, it just made it more easy to talk trash about.

      As I typed this I watched a "programmer" walk from co-worker to co-worker complaining about not having enough time to get their work done and asking for help on things that they should be perfectly capable of discovering on their own in half the time it has taken them to get up and interrupt other people on the team.

    2. Re:Is he a manager ? by metamatic · · Score: 1
      But they do care [...] taht the features are correctly documented, that the spec are there etc...

      If you really think all programmers are like that, take a look at a few open source projects. (Ruby springs to mind.)

      --
      GCHQ Quantum Insert installed. If only our tongues were made of glass, how much more careful we would be when we speak
    3. Re:Is he a manager ? by Cederic · · Score: 3, Interesting


      Beck is not a manager. That doesn't mean he lacks management skills (I've seen evidence that he does have excellent management skills) but reflects his hands-on nature. He writes code, and thinks about the process of writing code. And his thoughts tend to be somewhat broader than most peoples, and more complete, and when he shares them with others, better expressed.

      In other words, find books and papers and software written by Kent Beck and read the lot. If every programmer on the planet did that, even if they disagreed with everything he'd said, the IT industry would become immensely more efficient and effective overnight.

      Now consider Beck's quote that you have taken affront from. Think about new programmers, software heroes, cowboys, even experienced and capable programmers - they all want more toys, to be left alone to get on with their job (which they perceive as programming), that everything is handed to them on a plate. Your comment even reflects that - "enough time", "features are correctly documented", "spec".

      Real life isn't like that. And instead of whining about it, Beck stepped back and re-evaluated how to approach software so that he could deal with those issues, and still write top quality code, and still meet deadlines and give the customer value.

      No, Beck isn't a manager. He's quite beyond such limiting labels.

    4. Re:Is he a manager ? by ClosedSource · · Score: 1

      "He writes code, and thinks about the process of writing code."

      What production code has Beck personally written in the last 5 years? Or perhaps you mean he's a "paper" programmer.

    5. Re:Is he a manager ? by Cederic · · Score: 1


      I'm not entirely sure what production code he's been working on commercially. I do know that in his spare time he's worked with Erich Gamma (hopefully a name you recognise) writing and maintaining JUnit (http://junit.org/index.htm)

      If you're not a Java programmer you wont know that that's probably the second most downloaded and used piece of Java on the planet (behind the Sun SDK).

    6. Re:Is he a manager ? by bill_kress · · Score: 1

      Actually some research I read reciently noticed that if you continue to learn and use your mind throughout your life you remain more child-like and are less likely to grow up.

      Explanes a lot.

    7. Re:Is he a manager ? by Anonymous Coward · · Score: 0
      I do know that in his spare time he's worked with Erich Gamma (hopefully a name you recognise) writing and maintaining JUnit (http://junit.org/index.htm)

      Big Fucking Deal. JUnit may well be the second most downloaded piece of Java dev software (and is that perhaps because it ships with Eclipse?), but it's eXtremely overrated. It doesn't even support Java 5 generics. Agile? I think not. Wherever we've used it, we spend more time maintaining our tests than anything else, and refactoring becomes a mind-numbing trek through test cases, catching all of those lovely string constant dependencies.

      XP and unit testing is a crutch. Design it right, do it right.

  25. Treat programmers like other professionals! by Rearden82 · · Score: 3, Insightful

    "It's not all about programming. It's not all about programmers. Programmers aren't somehow special and to be protected and coddled."

    As a programmer, I agree 100%. I expect to work and be treated like any other professional.

    NOT as a lab rat for "extreme programming" or whatever buzzword-laden feelgood bullshit management scheme comes along this week.

    You wouldn't go to a painter and say "I want you to make me a painting. It doesn't matter what it consists of yet, we'll worry about that later. Just start out with a box or something and we'll meet every day and figure it out from there. And just to make damn sure you can't get anything done, I've hired another painter whose role is to sit around and annoy you." So why does that make sense for programmers?

    1. Re:Treat programmers like other professionals! by sh4na · · Score: 3, Insightful

      Amen to that, brother!

      First there was the "cat herder" motif. Programmer's are savage animals to be herded about by sensible managers, since they are wild and unpredictable and can't possibly function in a professional manner. That didn't go down too well, so after that programmers are this special breed that must be protected from the evil clutches of managers, like an artist on a quest trying to get rid of those pesky debt collectors. Nope, didn't work either. So now programmers are, really, nothing special, *bemused chuckle*, so they must work in pairs because they really can't discipline themselves all that much, so can't follow deadlines and schedules and program their work accordingly (pun intended).

      Really, wtf?!? Who comes up with this shite!?!

      I'm a professional. I study. I work. I have to deal with clients and managers and other programmers and emails and schedules and deadlines and projects and planning and meetings and $"#%$$ hard disk failures and stupid IDEs and dumb APIs and idiotic OSs and back pain from lugging the laptop around and hand pain from sitting on %$#"%$$% chairs with %&#%#$ desks and &%%"% mice and #$£&% keyboards and procrastination and bills and everything else one has to deal with in any job. And above all of this I still love the job, so I have the extra duty of being wacky some of the time just to fulfill my geek quota.

      And besides all of this, because I have this label someone stuck on my back somewhere without me noticing, announcing to the world that I'm a programmer, I have to also be a "lab rat [so aptly put by the parent, which is why I'm shamelessly quoting] for whatever buzzword-laden feelgood bullshit management scheme comes along this week" (or the next... and the next...), because someone is bound to read that buzzword-laden $#&%$%# and decide it would be so much more better amazing wonderful wow to make me work like the aforementioned buzzword-laden recommends as the oh so bestest way to get anything done with those darned critters^H^H^H^H^H^H^H^Hprogrammers!

      Could you buzzword-writing freaks, like, go pester the street vendors or accountants or something? I really need to finish these project design reports so I can start implementing the architecture I designed together with my team on - *gasp* - separate computers.

      --
      shana
      ......gone crazy, back soon, leave message
    2. Re:Treat programmers like other professionals! by Anonymous Coward · · Score: 0

      Just start out with a box or something and we'll meet every day and figure it out from there.

      What programming projects have you been on like that? Most of mine are "We'll like an application to do X as we have Y. It needs to react within T seconds and it needs to communicate with A,B, and C" Granted they don't know the specifics but you can go from there.

      Your painter example would be better if you had the painter complaining "they said that they wanted a house in the fields. Why didn't they tell me if they wanted Ionic or Doric columns!? Damn requirement monkeys can't even get me that! I'll go complain on slashdot"

    3. Re:Treat programmers like other professionals! by computational+super · · Score: 1
      "We'll like an application to do X as we have Y. It needs to react within T seconds and it needs to communicate with A,B, and C"

      Yep, that sounds like every spec I've ever gotten... oh, wait, you mean they say actual things instead of just saying the letters X, Y, T, A, B and C? Wow, you're lucky.

      --
      Proud neuron in the Slashdot hivemind since 2002.
    4. Re:Treat programmers like other professionals! by bytesex · · Score: 1

      This is insightful shit. Personally, although I've never tried or been forced into XP, I think it's typically something for young people; you know, the psychological approach. Young geeks work a lot (good), make many mistakes (bad), and don't communicate very well with other people other than their peers, and communication is what XP is all about. This frustrates managers, so they make sure, through XP, that they can still work a lot, but make fewer mistakes (through pairing, and testing a lot), and communicate more (by releasing often, and testing a lot (which requires documentation)). For older, more experienced programmers, I can't see XP be any good.

      --
      Religion is what happens when nature strikes and groupthink goes wrong.
    5. Re:Treat programmers like other professionals! by Cederic · · Score: 1


      Beck and Andres are also programmers.

      Most XP projects start using XP because the programmers wanted to. It makes sense for them.

      If you're a professional then why are you bleating about getting shit requirements and being unable to start? Why aren't you doing something about it?

      Hint: Some people did do something about it. They even wrote it all down for you. They gave it an odd name, "Extreme Programming". Maybe you'd like to read about it, possibly even give it a go, actually expand your horizons and learn something. Or you could just post to Slashdot about it being buzzword laden crap without understanding the concepts in the slightest. Your choice.

    6. Re:Treat programmers like other professionals! by Cederic · · Score: 1


      Managers find it harder to come to terms with XP than programmers.

      The people that came up with XP are all (and I hope none of them read this ;) old people. They have decades of experience.

      They've also published many papers on software engineering and heavily advanced the state of that discipline. They are older, more experienced programmers. Why can't you see XP being any good for them?

    7. Re:Treat programmers like other professionals! by ClosedSource · · Score: 1

      Yes, these guys are old and experienced, but one shouldn't conclude from that other equally old and equally experienced developers necessarily buy into XP.

      I'd also say that most of the methodologists haven't been working programmers for many years. You can't write books, give lectures etc and still work full time as a programmer.

    8. Re:Treat programmers like other professionals! by Cederic · · Score: 1


      My experience is that the top guys in the industry - I'm talking about Beck, Fowler, the three amigos (didn't one of them die?), the Gang of Four, Anders Hejlsberg, Cockburn - are all still very hands on. They do publish a lot, they do put a lot of thought into software engineering, but they do also still get very actively involved in software projects.

      No, they're not 100% programming. I must confess, I'd rather Cockburn spent 20% of his time programming and the rest of it writing books and giving subjects on the subject. He's an arch-methodologist, and he puts his ideas into practice, but he makes people think, and he helps them improve how they do what they do.

      I kind of buy into that.

    9. Re:Treat programmers like other professionals! by Anonymous Coward · · Score: 0

      Getting a CS degree does not make you a programmer. Beck is a manager in mind, body and spirit. He has no practical experience, and he is attempting to build an empire around convincing other clueless PHB types like himself to force programmers into yet another moronic system that hurts instead of helps. Every big project that was going to prove how great XP is was a giant failure. Even all the ordinary, every day projects in ordinary every day companies fail, like our web team here, our winCE team here, our symbian team here, our linux mobile team here, etc.

    10. Re:Treat programmers like other professionals! by ClosedSource · · Score: 1

      Some of these guys are great at what they do, but I won't necessarily consider them working programmers. In any case, I doubt that Anders Hejlsberg sits down at his keyboard with somebody looking over his shoulder.

    11. Re:Treat programmers like other professionals! by hax4bux · · Score: 1

      Beck and Andres might have been programmers once.

      Now they are cult leaders w/seminars to fill and books to sell. It is a mistake to believe this is anything more than self promotion.

      When this fad passes, Beck, Andres (et al) will look just as stupid as Yourdon.

    12. Re:Treat programmers like other professionals! by Cederic · · Score: 1


      I'm not sure this 'fad' will pass. I doubt XP will ever be mainstream, but I suspect it'll never go completely away.

      It has certainly influenced a lot of Agile methods, and influenced a lot of people beyond that. XP as a methodology may not be deemed a 'success' within the industry, but I think a lot of people recognise the contribution it's made.

    13. Re:Treat programmers like other professionals! by dubl-u · · Score: 1

      NOT as a lab rat for "extreme programming" or whatever buzzword-laden feelgood bullshit management scheme comes along this week.

      And maybe that's the problem. I'm a developer, and when reading about Extreme Programming I said, "This is either crazy or brilliant, and I have to find out which." So got a client to try it, and it worked wonderfully for me. Managers will never really get it, because it was devleoped by programmers and for programmers. So if they were to explain it and push for it, I imagine it would sound retarded.

    14. Re:Treat programmers like other professionals! by dubl-u · · Score: 1

      Really, wtf?!? Who comes up with this shite!?!

      Extreme Programming was invented by programmers; they felt it was the best way for them to work on the project they were doing. All of the main Extreme Programming proponents still write code regularly, and some even blog in detail about coding.

      I'm a programmer, and I love it. If you want to know why, don't hesitate to ask.

    15. Re:Treat programmers like other professionals! by sh4na · · Score: 1

      That was actually a rhetorical question on my part, but I'll bite.

      For a start, coding some nice algorithms to solve sudoku problems is not exactly the same as day-to-day coding in a real world company. But that actually doesn't matter to what I was saying: My point was, all these methodologies feel like ways of evangelizing a population of professionals who just happen to have had the bad taste of being programmers.

      While I enjoy and apply many work methods according to what the project needs, I deeply resent reading supposedly helpful professional books where I am, by way of my profession, pictured and treated as a child who doesn't know better and so must be controlled. That quickly sends the book out the window and the methodology down the drain, because a methodology that is based and implicitly condones on such a view of professionals is not worth the paper it is written on.

      Being programmers themselves only makes the situation worse, as they are describing themselves! So they are children to be wrestled with and controlled and given nice playing methods so they will stick to the rules and not bother anyone. Nice way of showing that they are responsible and knowledgeable enough for me to read and follow a methodology they are suggesting. They are probably saying that stuff to appeal to clueless managers, who probably think like that, but that only makes their ideas worth even less.

      So I got no quarrels with work methods per se, just with the low-life buzzword-laden bottom-feeders shoving books filled with the latest (what did I call it? Ah, yes) "whatever buzzword-laden feelgood bullshit management scheme" they managed to come up with to fill their pockets.

      Again, I emphasize: good methodologies are very useful in any sort of project, be it one-man or multi-corporate-department complex. However, I deeply, deeply resent reading about what a $#%& retard programmer I am, can't even program my day and discipline myself to do any useful work. But we've got the answer, woo woo! Here's this way of doing that so I can be saved! Ale-f*****g-luia! As long as you make sure someone is always looking over your shoulder, you're great!

      And another thing... why do you x-prog guys just always sound like you're some kind of jehova's witness that just knocked on my door?

      I'm a programmer, and I love it. If you want to know why, don't hesitate to ask.

      eh??!?!? WTF?!?

      Like, I've been saved, you can be too, just ask? You're not the first say this, I'm wondering, is this some sort of religious thing? Because you all really sound alike... do it our way or the highway, there's no better way, if you don't like it then you're not doing it properly, and all that stuff... ?!?!?

      --
      shana
      ......gone crazy, back soon, leave message
    16. Re:Treat programmers like other professionals! by dubl-u · · Score: 1

      Like, I've been saved, you can be too, just ask? You're not the first say this, I'm wondering, is this some sort of religious thing? Because you all really sound alike... do it our way or the highway, there's no better way, if you don't like it then you're not doing it properly, and all that stuff... ?!?!?

      No, it's not a religious thing. I agree that some people are dogmatic about it and I agree those people are annoying. For me it's a pragmatic thing. I want to make good stuff, and this is the best way I have found to make good stuff. When I find better ways, I will do those. For example, domain-driven design is something I've added to my toolbox more recently.

      The "if you don't like it you're not doing it properly" is an interesting point. Every single time I have talked to somebody who hated pair programming, I find out they were doing it wrong. Generally they are doing "one person watching another programming" which is a boring waste of time. Or they tried "arguing with an asshole all day programming" which is also not so fun. All of the people I have personally introduced to pair programming ended up liking it, and this includes a wide variety of engineers. So after going through the "I hate pair progrmaming" discussion twenty or thirty times, my starting assumption is indeed that people who hate it have probably never tried what I think of as pair programming. Sorry if you don't like that, but I'm not sure what else to do.

      But if you don't want to know about it, that's fine by me. I was just offering. It's not like I get a bounty from L. Ron Hubbard or anything. I've got plenty to do otherwise.

      where I am, by way of my profession, pictured and treated as a child who doesn't know better and so must be controlled.

      I think that one Beck quote is getting taken out of context, and it isn't from any of the XP books. The methods are just the opposite in spirit from the one you describe above. XP teams are supposed to be self-managing in most ways. The main non-developer role in XP is a product manager whose only job is to say what features are wanted and in what order. All technical matters (including all estimation) are the strict provenance of the team of developers.

      Right now I'm doing an agile transition with one team where the manager spent all his time breaking down the features into little technical bits and parcelling them out, micromanaging the developer work queues. Three months in he's stopped doing that. He just says what features are top priortity and the team parcels out the work as they see fit, often in non-obvious ways. They're happy because they're more in control of their lives; the manager's happy because he can focus on things he things are more important.

      There's actually a heavy debate in the XP world about "rules" at all. Beck regrets ever having phrased things so strongly because some people took them too seriously. Others like Jeffries feel that rules are a useful starting point, like the rules you give to a beginning skier, knowing that they will leave most of them behind on the bunny slopes as they get the spirit behind the rules. But all of them agree that by-the-book XP is meant as a starting point rather than an end result.

      You'll note that there's no XP certification organization, and no official checklist that tells you whether or not you're doing XP. That's entirely on purpose. XP is meant as a set of tools for people to be more productive with, not a stick for managers to beat employees with.

  26. GUI prototyping tool by pnone · · Score: 2, Funny

    There is also one good tool called Petra supporting extreme programming prototyping http://petra.cleverlance.com/ We use it and love it.

    1. Re:GUI prototyping tool by ynohoo · · Score: 2, Insightful

      What's up, didn't you like the "Funny" mod you got the last time you posted this?

      I must admit I found this site disconcerting - I'm unlikely to buy design tools from people who look (on this site) like they are in the "manic" phase of their bi-polar disorder...

  27. mod parent up by ameline · · Score: 1

    That was the most sensible post I've seen here so far.

    --
    Ian Ameline
  28. Who uses XP anymore? by Anonymous Coward · · Score: 1, Interesting

    Most people have moved onto other agile methods like SCRUM. XP had a lot of hype, by its authors mainly, and now many of its techniques have proven to unusable and have no value. I know of at least 1 300 billion dollar company that tried it and left it behind because it was wasteful in many ways.

    1. Re:Who uses XP anymore? by jpbelang · · Score: 1

      Scrum is more project management oriented. Many people use Scrum/XP

      --
      JP http://www.wearerite.com
  29. Re:Overrated == Someone answer this by E++99 · · Score: 1
    Sorry to ask, but can someone give an example of a field of "real engineering" which uses formal methods to ensure correctness, and of the formal methods used?
    I would also be interested in what that is, if anyone knows. As far as I know, such "real engineering" means that the design of the bridge is put into the computer, and the computer simulates the forces of gravity, wind, and whatnot, and monitors the simulated stresses on the materials, comparing those against established safe parameters for those materials. Of course, automated testing is done on software too, but the search-space for the possible user interactions with a big software system is vastly larger than the possible stresses on a bridge, so such testing is not very conclusive.
  30. Agile Programming == Late night infomercial by MrData · · Score: 3, Insightful

    Agile Programming is like a late night infomercial without the "these results are not typical" disclaimer.

  31. Re:Overrated -- Super-Extreme Programming by E++99 · · Score: 1
    A lot of the bad code you see around stems from 'lone ranger' coders, not realizing the fact that, programming like most other disciplines, is collaborate work.
    Sure, there's is collaboration involved in pretty much anything you can get paid for. However, bad code simply comes from bad coders. If take a bad coder, pair him with another coder, and find that the quality of code increases, then try getting rid of him altogether, so that the good coder isn't bothered. The quality will increase even more! Seriously, there may be certain beginners who can produce better code in pairs than individually, but whether it came from a pair, trio, or quartet, you should assume that such a product is not ready for production until someone who knows what he's doing looks at it.
    Except for kitchen table projects most code is written with other people. Other programmers, designers, project managers, users ( damned be the last two) , and other stakeholders. XP addresses a lot of the problems you have when collaborating with these and so it can help you to get more time to code.
    Oh good, so now the project managers, users, and stakeholders are going to sit behind me while I code? Terrific! Personally, I use what I call Super-Extreme-Programming. That's where the program managers, users, and stakeholders all get my email address, but none of them get my phone number or are welcome in my physical location. (Requirements analysis is done at their location, of course.) It takes a little discipline on their part, but the end-product makes it all worth it.
  32. Re:Overrated == Someone answer this by Peter+La+Casse · · Score: 1

    I'm not a real engineer, but my layman's understanding is that the engineering equivalent of formal methods involves the mathematical calculation of loads and stresses.

  33. Re:Overrated == Someone answer this by aaribaud · · Score: 1

    E++99:

    Mikkeles did answer citing Structural engineering - analysis of components and connections based on the science of strength of materials, and Aeronautical engineering - design is based on computer simulation of air flows over wings and fuselage, then confirmed by testing, which is not antiethical to formal methods of physical components.

    As I was suspecting, those are valid engineering examples, but neither exhibit formal methods as such. They use analytical methods, which are fine and efficient, but which are nowhere near formal methods as I know them. And neither are more "real engineering" than SW engineering; they are reality engineering if one so wishes to differentiate them from SW.

    In fact, SW is the only engineering where formal methods might be considered, and SW engineering can be just as reality oriented as structural engineering. Indeed, structural engineering could barely be achieved today without SW.

    However, I would venture that possible stresses on a bridge can indeed outnumber possible interactions with some SW. It just depends on how close to reality you want your real structural engineering to be. Finite elements, paradoxically, can always be broken in smaller pieces. :)

  34. Formal methods in chip design by Morgaine · · Score: 2, Interesting

    Chip design is a good example of such uses in "real engineering". The whole semiconductor industry is permeated with "strongly formal" tools implementing different types of formal methods at their core. These vary hugely, from loose fuzzy logic design aids to stronger expert system parameter, timing and topology validation, to the full blown formal methods that a language-based computer scientist would recognize.

    And it's been going on for decades. The FPU of the well-known transputer CPUs from the 80's were designed using formal methods.

    If integrated circuits were crafted using our current manual programming methods, 99% of computers would be dead 99% of the time.

    --
    "The question of whether machines can think is no more interesting than [] whether submarines can swim" - Dijkstra
  35. Ding-Dong! by sh4na · · Score: 1

    Hello. I have a delivery for you.

    *WHAM* <-- sarcasm cluebat

    You're welcome.

    --
    shana
    ......gone crazy, back soon, leave message
  36. Re:Overrated == Someone answer this by aaribaud · · Score: 2, Informative

    As a non-layman, highly SW-based, real enough engineer (and other than that an almost normal person), I would not parallel, for instance, structural analysis in civil engineering with formal methods in SW engineering. "Formal method" is the name of a specific kind of SW analysis tool, based on mathematically proving the software, not taking stress scenarios into account (stress simulation for SW is called "testing" :) ).

  37. The real problem is getting a cohesive team by Tallfeather · · Score: 1

    Taken as is, XP can work very well - for teams that are already strongly of that mindset.

    However, typical development teams are not staffed by management based upon styles, ideologies, or personalities. It is often by things such as where they sit (seriously) and whether or not they just finished something. A group of 5 "resources" are put together and told to work. If you take 5 random people and try to get them to use XP well, I can pretty much guarantee things won't work terribly well. To be fair, any process is going to have trouble with the typical staffing methodology prevalent in the marketplace.

    If you get a bunch of people who lean towards the XP style, use XP. Great. If not, use a different model. Tailor your process to the people. A process can be changed easily, people's personalities can not.

  38. Extreme Hogwash by roman_mir · · Score: 4, Insightful

    First a disclaimer: I worked on an ADP project that involved Intelliware - an XP shop to build a mutual fund prospectus preprinting system (system that collected information from different mutual fund vendors, and used customer information to decide what and when to print and to mail to that customer.) This was a second iteration of the project. The first iteration had to be scrapped, because the same vendor provided a solution that did not scale to the task, when major Canadian banks came online.

    My impression from the entire excercise, (which included daily standup meetings, story cards, paired programming, unit testing, end of the day documentation.) The process became very very wasteful. I personally saw that putting 2 contractor programmers, each at 90/hr at one workstation does generate dialog between the programmer, where both have to generally agree on the approach to any given problem but I did not see any performance improvement achieved by this approach over havin one 90/hr contractor doing the same thing. Since the requirements of the system were still being 'refined' and since there still were deadlines to achieve, the pair had to produce as much code as possible in a very short time period and various bugs still slipped through the process (most of which admittedly were caught by the unit testing, but unit testing.)

    The daily standup meetings were mandatory of-course even though most people loathed those. There still were 'overal architects' on the process, and due to the politics of this specific vendor they forced a custom server solution upon the customer (even amid my vivid objections. I was trying to get the vendor to use existing server and framework solutions, unfortunately my voice was not heard, there was no will to prevent the imminent demise of the project by concentrating on the problem at hand and not getting ourselves into a proprietary application server territory.)

    Basically the project was not delivered on time (and as I at the time predicted) went over the original time estimates by about a year. I was forced to leave 3 months into the project because I became to frank with the department director. 3 months after I left, Intelliware was forced out the door as well. The project was partially delivered within the time that I estimated, the department director had to leave the department as well.

    I do not get any warm and fuzzy feelings about anyone promoting XP, I right away start looking for ulterior motivations. My personal feeling is that people who do not want to carry any responsibility for the project, for the code, for the requirements welcome XP (or can be easily swayed to accept that methodology.)

    In XP noone is really personally responsible for anything, and that attracts people who want to have it easy. Documentation is shunned upon, any forward thinking is met with contempt. Any questioning of the process/methodology is considered a heretic. Sweat shop mentality dominates XP, and it is not surprising, considering that it takes 2x as many people to deliver the same solution for 2x the money. Obviously there is a drive for those, who are actually producing code to work as fast as possible without any room for thought.

    I did however find that unit testing is a very good approach to testing and that wiki style documentation is excellent if used properly.

    1. Re:Extreme Hogwash by Cederic · · Score: 1


      >> Basically the project was not delivered on time (and as I at the time predicted) went over the original time estimates by about a year

      That doesn't sound like an XP project to me at all. How do you go over by a year if you deliver every 2-6 weeks?

      >> Sweat shop mentality dominates XP

      That's ludicrous. One key tenet of XP is "sustainable pace". Don't burn out, don't work late nights.

      >> it takes 2x as many people to deliver the same solution for 2x the money.

      You are aware of the body of evidence (academic and business) that shows that while pair programming is less efficient than solo programming (in a lines of code delivered sense) it is nowhere near twice as slow and the code delivered is so considerably higher quality that it more than makes up for the overhead?

      I call bullshit on your statement you were using XP. You may have used many of the practices, and you may have called it XP, but you didn't do it.

      Don't feel bad - it's a bloody difficult thing to do properly. Possibly too difficult. By far the highest discipline method I've ever used. But don't badmouth it just because the company employing you didn't do it properly.

    2. Re:Extreme Hogwash by roman_mir · · Score: 3, Insightful

      That doesn't sound like an XP project to me at all. How do you go over by a year if you deliver every 2-6 weeks? - you didn't read it, did you? For various political reasons instead of just concentrating on business at hand, the abovementioned firm decided to write everything you can find in a commodity application server by hand. My estimates included this fact, the XP provider who I named convinced the client that everything will be done by the client's deadline (about 4 months after the project began.)

      Delivery of various pieces was done every 2-4 weeks actually, but the application server part feature creep that was unapparent to the client but obvious to me reared its ugly head. Every time a piece of code was 'delivered', it became apparent that it had to do more and more, and every time it had to be redone.

      My point is that XP provides excellent conditions for this kind of 'delivery' mechanism because it objects to doing any real architecture (analysis of the requirements and features upfront.)

      That's ludicrous. One key tenet of XP is "sustainable pace". Don't burn out, don't work late nights. - there was almost no late nights, but everyone got the CTS. One person at the computer had to provide the code that two people would generally provide during the day.

      You are aware of the body of evidence (academic and business) that shows that while pair programming is less efficient than solo programming (in a lines of code delivered sense) it is nowhere near twice as slow and the code delivered is so considerably higher quality that it more than makes up for the overhead? - I am aware of my own experiences and I don't have to submit my experiences to any 'body of evidence' (academic or business.) XP forces the pair to provide similar amount of work as if they were working seperately.

      I call bullshit on your statement you were using XP. You may have used many of the practices, and you may have called it XP, but you didn't do it. - you can call it whatever you want, Intelliware is the top XP solution provider in Ontario.

      Don't feel bad - it's a bloody difficult thing to do properly. Possibly too difficult. By far the highest discipline method I've ever used. But don't badmouth it just because the company employing you didn't do it properly. - First of all, I was a contractor for ADP, and Intelliware was an outside resource, but all (4) ADP people were put into Intelliware teams and we had to work together, so I wasn't employed by an XP company.

      Secondly, what I am feeling from you is exactly the same attitude that I was getting from that XP shop - do not badmouth XP. XP cannot be wrong. I am under impression that XP is a religious movement rather than a management solution to a technical/management/social problem.

      The fact that so often you can hear people say exactly this: it's bloody difficult thing to do properly, should be a red flag - it is just like any other methodology or any other process. Anything is difficult to do properly and in theory anything will work well if done properly.

      Give me a bloody break, just because you bought into the entire XP religious propaganda, doesn't make XP any more valuable a tool than any other methodology, process or a combination of requirement/design/development standards.

    3. Re:Extreme Hogwash by Oligonicella · · Score: 1

      "How do you go over by a year if you deliver every 2-6 weeks?"

      You deliver the entire and completed project every 2-6 weeks? Oh, that's obscu-speak for deliverable you're using. Tiny pieces are delivered every 2-6 weeks, just like with other techniques. He said the project was a year overdue. Read -> comprehend.

    4. Re:Extreme Hogwash by FoeQueue · · Score: 1

      Please point out links to where XP is actually sucessful on a large scale project. I have yet to see any definitive proof, other than laugh at the great genesis of XP, the GM debacle.

    5. Re:Extreme Hogwash by AuMatar · · Score: 1
      That doesn't sound like an XP project to me at all. How do you go over by a year if you deliver every 2-6 weeks?


      Simple- they wanted the entire thing finished in X time. Welcome to the real world. You get there either by changing requirements (dropping features) or changing the schedules. Releasing every 2-6 weeks is just not realistic for most programs- for example this propgram appears like it was finance based, working with point releases may not just be a bad idea, it may be illegal if auditing features are not yet implemented.

      That's ludicrous. One key tenet of XP is "sustainable pace". Don't burn out, don't work late nights.


      Most XP places I've seen work later hours than normal shops.

      You are aware of the body of evidence (academic and business) that shows that while pair programming is less efficient than solo programming (in a lines of code delivered sense) it is nowhere near twice as slow and the code delivered is so considerably higher quality that it more than makes up for the overhead?


      Personal experience and everything I've read show the exact opposite- its more than twice as slow and has lower quality.

      call bullshit on your statement you were using XP. You may have used many of the practices, and you may have called it XP, but you didn't do it.


      Oh yeah, the usual XP excuse- if it doesn't work you fucked up. It can't possibly be the methodology itself.

      If the methodology requires absolute rigid adherence for it to work, thats a fatal flaw in it right there. Not that XP doesn't have enough other fatal flaws.
      --
      I still have more fans than freaks. WTF is wrong with you people?
    6. Re:Extreme Hogwash by Cederic · · Score: 1


      FFS, Intelliware may be the top XP solution provider in Ontario, but you've said yourself: Feature Creep

      In a proper XP project that is impossible. You only implement features for which there are stories. The customer chooses which stories to implement. Feature creep ceases to be an option.

      Give me a bloody break, and don't badmouth XP until you've done it properly. I'm quite happy for you to criticise XP - shit, I can give you a couple of pages of solid criticism myself - but at least base it on reality, not your experience of some fucked up cowboy method that someone told you was XP.

      I haven't bought into the entire XP religious propaganda. If I had I'd be insisting we use it where I work now. I don't, because I evaluate multiple development methods and I recommend the appropriate one for the work being done, in the environment in which it is happening. I just get pissed off with the dogmatic refusal from a significant percentage of the IT industry to actually objectively evaluate new and different ways of working. Stop holding my industry back you luddite wankers.

    7. Re:Extreme Hogwash by Cederic · · Score: 1


      >> Personal experience and everything I've read show the exact opposite- its more than twice as slow and has lower quality.

      That's very interesting. I'd be interested to see what you've read about it - I've read a couple of case studies, a few academic studies and heard a lot of anecdotal evidence, and you've just contradicted a significant proportion of it.

      I did just find http://agilealliancebeta.org/system/article/file/1 215/file.pdf#search=%22pair%20programming%20effici ency%22 which is interesting reading. It's nearer your view than mine, although it quotes two other studies that mirror my understanding. :)

      >> If the methodology requires absolute rigid adherence for it to work, thats a fatal flaw in it right there.

      My experience is that XP is very very difficult and also needs a hell of a lot of discipline. That alone makes following it pragmatically impossible for most development teams. That doesn't invalidate the methodology, it just makes a decision to adopt it require far more commitment and certainty than most people are prepared to give.

      XP is not a silver bullet. (Fred Brooks seems to be onto a winner there.) I just get irritated as hell at people denouncing it without having actually tried it properly. All too often it rings of "I don't work like that, it must be wrong"

    8. Re:Extreme Hogwash by roman_mir · · Score: 2, Interesting

      FFS, Intelliware may be the top XP solution provider in Ontario, but you've said yourself: Feature Creep - absolutely. A Feature Creep caused by the politics of the vendor, who used XP to his own advantage because it is just so easy to hide the fact that Feature Creep will happen.

      In a proper XP project that is impossible. You only implement features for which there are stories. The customer chooses which stories to implement. Feature creep ceases to be an option. - Bullshit. The customer is told that in order to implement the business requirements various frameworks have to be put in place. It is true, the frameworks have to be put in place, what is not made apparent is that these frameworks do not have to be implemented in house. XP is not to blame for the politics of the company, but it is a bloody excellent mechanism to make it nearly impossible to give any estimates on what actually will happen when these frameworks, that need to be implemented, start blowing up into a 'proper' application server.

      Give me a bloody break, and don't badmouth XP until you've done it properly. - oh, jeez. So what you are telling me is that you apparently know that XP was not done properly by this top XP provider in Ontario (a bloody huge province.) This is insulting to the intellect of the casual reader.

      I'm quite happy for you to criticise XP - shit, I can give you a couple of pages of solid criticism myself - but at least base it on reality, not your experience of some fucked up cowboy method that someone told you was XP. - I don't see you giving me anything but statements, that are full of horse manure. Apparently you are THE authority on what makes a proper XP implementation. Whatever. I worked on XP projects twice in my life, I researched what XP is supposed to be and compared to my experiences. As far as I am concerned the Intelliware XP experience was as close to a 'perfect' XP experience as anyone should ever hope to get. I was there, what is your basis for your statements?

      I haven't bought into the entire XP religious propaganda. If I had I'd be insisting we use it where I work now. I don't, because I evaluate multiple development methods and I recommend the appropriate one for the work being done, in the environment in which it is happening. I just get pissed off with the dogmatic refusal from a significant percentage of the IT industry to actually objectively evaluate new and different ways of working. Stop holding my industry back you luddite wankers. - holly crap. So I am a luddite wanker now, who is dogmatically refusing to objectively evaluate a new way of working.

      I evaluated it. I worked with it. I am being objective here: from my experiences, XP suggests some nice features (unit testing/wiki on the go documentation,) that can positively influence design/development of a project. From my experiences XP is also a great management tool to avoid any blame for any wrong doing (and people do the wrong thing quite often.) From my objective point of view, XP is just another methodology and has the same limitations as any other methodology and does not provide an obvious edge over any other methodology if any of those methodologies are properly followed.

      But forget you, I am not answering to any of your accusations any longer.
      --

      For the normal readers, not for the XP evangelists: Unit testing does objectively help to develop better code. Wiki documentation (and xPlanner especially for CVS checkin flag blocking) can be useful tools IF people in the team do not actively hate the idea. If someone (a team lead hopefully) decides to use the Wiki as supplementary documentation source, it may become a very useful tool indeed. All kinds of communications can happen through this documentation resource.

      As to paired programming: it is up to your project management. If they will to pay for it, go nuts. It won't make your code worse, but again, objectively speaking, I found paired programming to be ONLY useful at moments w

    9. Re:Extreme Hogwash by Anonymous Coward · · Score: 0

      Is this the project to which you are referring? It looks like it won an award:

      http://www.cipa.com/award_winners/winners_05/ADPIn vestorCommunications.html

    10. Re:Extreme Hogwash by roman_mir · · Score: 1

      Absolutely. That's the project. However you do not see there what is behind the curtains and exactly how late it was, how difficult it is to maintain or to scale any further. Actually I believe that in the past year, they completely discarded the Intelliware solution and switched to an application server.

      Don't misunderstand that the award is for - the business behind this project is sound. From business poin of view this project is great. But it was more than a year overdue, they spent 5 times the amount of money building it than they thought they would. At the end it is all still just a development cost of-course.

    11. Re:Extreme Hogwash by rewt66 · · Score: 1

      You have several times stated what the problem was: politics. Newsflash: Software development methodologies do not fix political problems. Not the waterfall, not XP, not agile, not Scrum, not anything. So you had some idiot managers who insisted on developing everything in-house and who did this insane feature creep, and you're blaming XP because it couldn't save you from politics and idiot managers. Sorry, I'm not buying it. In that situation, only one thing can save you - firing the idiot political managers. Nothing else works.

    12. Re:Extreme Hogwash by roman_mir · · Score: 1

      So you read all of it and yet you missed the point.

      XP made it possible to hide the fact that the Feature Creep was inevitable in that particular situation, where the frameworks were to be implemented in the house.

      Because XP prevents any real architectural discussion, everything that needs to be developed is designed during development and obviously the resulting Feature Creep in this case did not come from the business side of the application, but from the development side.

      You have to read deeper into the context of the post.

    13. Re:Extreme Hogwash by rewt66 · · Score: 1
      I still don't buy it. "XP made it possible to hide the fact that Feature Creep was inevitable." OK, I can accept that. But again, any methodology will allow that unless you do some kind of gap analysis. And you can (and should) do gap analysis with XP, too - been there, done that.

      I mean, you can hide gaps and feature creep in a several-thousand-entry project tracker, too. The issue isn't the methodology, it's that the people running the show can't see the gaps themselves and won't listen to the people who can see them. The problem isn't XP, it's the people. In this particular case, they happened to buy the idea of XP as a silver bullet that could save them from themselves, but it couldn't.

    14. Re:Extreme Hogwash by roman_mir · · Score: 1

      You are arguing with me over one specific detail. I gave a break down of what I think of various XP methods just two posts above. I have witnessed various situations over the years, where the Feature Creep became a problem, but I swear that only with XP did the Feature Creep come from the development side and not from the business side.

      Any methodology/process can get lost in the business side Feature Creep, but with XP it became apparent to me that there are other kinds of Feature Creep - development Feature Creep.

      In XP you are actively prevented from looking more than one story forward, that is the actual problem. My point is that following XP in a blind way will cause some sort of a project collapse. The project has to be evaluated from an overal point of view and in this particular case, precise following of XP methodology made it impossible to do so.

      I am not dissing XP completely, again look at my methodology break down. However I am dissing following XP to the letter. For your project's well being, be careful with following a methodology for the sake of evangelism.

    15. Re:Extreme Hogwash by rewt66 · · Score: 1
      I can't argue with that. All I'm saying is, it's still not just XP. Following any methodology blindly, to the letter, is a recipe for disaster.

      But I must admit that the "developer creep" is a new one to me. Sounds like the developers either didn't understand the architectural implications of the stories, or lied about how hard they would be.

    16. Re:Extreme Hogwash by bill_kress · · Score: 1

      I'm sort of neutral about XP still. My take is that almost all the ideas are good, but implementing it in todays business world is virtually impossible.

      Most people seem to use parts of XP--often parts that make their lives easier WITHOUT using the parts that compensate.

      A few examples of interrelating practices:
      light (or, some people think no) documenting is possible because of the bullpen/peer programming.
      Large refactors are simple because of 100% test coverage.
      100% test coverage is possible because you test before code.
      Light (or no) up-front design is possible because you ruthlessly refactor.
      Don't need comments because the code is fully factored and readable.

      Perhaps one day I'll draw a chart of how they all interact, at least for my own edification.

      The problem is, most groups leave off a step or two that are uncomfortable...
      "I won't do any upfront design, but we don't have time to re-write an entire package that needs it."
      "We don't like to do comments and XP says we don't have to, someday we'll get around to refactoring to make the code readable, but it's dangerous because our incomplete unit tests don't catch everything."
      And possibly the biggest:
      "We'll skip the customer requirements a normal project would provide and just use these tiny descriptions on index cards, but we won't have a customer on-site as part of our core team because none are available"

      At this point I get really weary when anyone says "We use XP" but follows it up with "We can't do THAT XP practice because..."-without attempting to compensate for the missing practice(s).

      I also agree with you that it tends to be a religion amoung some, in many I'm afraid that religion is simply a result of wanting to believe that you don't have to write comments or do any up-front design, but I have to believe that most believe that following XP really will create and enable better programmers that can handle the responsibility XP gives them.

      So, my question to the parent would be: do you really think that the XP practices and values were all correctly observed and implemented and that the process failed, or do you think that the implementors may have called themselves XP but actually didn't implement the entire set of practices--which caused it to fail? (I'd really like an answer because I'm still evaluating the practice myself)

      Because your contractor claimed to be XP, it doesn't mean their team was using it on that project.

      For instance:

      The four month deadline that the XP shop agreed to, do you think that was from sales or do you think that, as per xp, all the User Stories were written by the customer, laid out on cards, discussed by the programmers, and had times allocated before the 4 month number was given? This alone would cause the project to fail, even if everything else was 100% XP.

      If the original user stories actually tallied to 4 months (by programmers estimates), were a significant portion left as "removable" so that there was some flex in the schedule?

      Did you notice programmers activly switching off, constantly re-aranging pairs (each engineer should have at least two different pairs a day) and having nearly constant bullpen discussions?

      Was there a customer and a QA representive in the core group--appearing at each stand-up meeting and discussing design issues? Was the QA rep. designing and implementing approval tests from day 1?

      Was there complete visibility? Every week the customer should have known EXACTLY how long the remainder of the project would take. Every week the estimate should have gotten more accurate, not less. The customer MUST look at the story cards on the wall every day (at least during the standup meeting) and notice how many are going to be done next week, how many weren't done last week, how many still haven't been moved into the "Active" category, ... How could it possibly have gone so wrong with constant feedback and cutting of user stories?

      Is there any point

    17. Re:Extreme Hogwash by ClosedSource · · Score: 1

      "You are aware of the body of evidence (academic and business) that shows that while pair programming is less efficient than solo programming (in a lines of code delivered sense) it is nowhere near twice as slow and the code delivered is so considerably higher quality that it more than makes up for the overhead?"

      I'm aware that a number of studies like this were conducted improperly. If you indentify which ones you are referring to, I can let you know if they've been debunked.

    18. Re:Extreme Hogwash by Anonymous Coward · · Score: 0

      I do a little more digging on the project in question (http://cipa.com/award_winners/winners_05/ADPInves torCommunications.html) and I'm left with three things:

      1. The customer who engaged the vendor to build this product is extremely happy
      2. The product supports a profitable business model
      3. The product has been recognized as one of the best in Canada by CIPA (whom by their own claim
      are the premier showcase for Canadian IT and innovation)

      I don't particularly care what methodology the product was built with, but if you can say those three things at the end of a project, it's been a success. Case closed.

      Full disclosure: I have worked on both XP and non-XP projects and have come to the conclusion that regardless of the methodology, you need the right people and the right tools to get the job done. Strictly following guidelines setup by some big thinker on a different project will seldom lead to desired results.

    19. Re:Extreme Hogwash by sh4na · · Score: 1

      I can't argue with that. All I'm saying is, it's still not just XP. Following any methodology blindly, to the letter, is a recipe for disaster.

      Wait, now I don't get it... isn't the problem with most XP projects that fact that one *doesn't* follow the methodology to the letter? Didn't the xp guys state that it's an all-or-nothing methodology, you have to do it all for it to work properly? Isn't a methodology suppose to have mechanisms to allow you to take maximum advantage of the development process? So how is following any methodology to the letter a recipe for disaster?!?

      You're saying that following *XP* to the letter is a recipe for disaster, right? Because it's missing the big picture view essential to development? But if that is true, than it is such a fatal flaw in the methodology as to render it worthless. Not that the specific methods are worthless, mind you, but that the methodology as a whole is. Because either a methodology is sound, or is not. Either it's self-consistent, or it's not.

      If you say that it works but then you say that for it to work, you have to add something from other methodologies, such as a top down view or something to fill the gap that it has on the big-picture view part, then, after all, you're saying that it doesn't work on it's own.

      If you say that it doesn't work for others because they didn't follow it to the letter, but then you say it works for you because you're *not* following it to the letter, you're adding stuff from the outside, it's a bit of a contradiction there, hmm?

      So maybe the people saying it doesn't work for them are really following it to the letter, and falling in the problem gap it has, while you're skirting the edges but adding extra stuff, eh?

      Hmmmm, food for thought...

      --
      shana
      ......gone crazy, back soon, leave message
    20. Re:Extreme Hogwash by roman_mir · · Score: 1

      Hold on, so what do you expect a company to do, when it posts on the Internet? Say that its project was more than a year overdue? Say that the amount of the money that was spent was at least 5 times the estimated original? Say that the vendor did not come through on the original deadlines? Ok.

    21. Re:Extreme Hogwash by Anonymous Coward · · Score: 0

      I'm left with your word as a disgruntled ex-employee against that of a reputable, publicly traded $9 billion dollar company.

    22. Re:Extreme Hogwash by roman_mir · · Score: 1

      But I was never an employee. A reputable $9 dollar company, ha :)

    23. Re:Extreme Hogwash by rewt66 · · Score: 1
      First, you're combining what I said with what other people said, and looking for consistency. That ain't gonna happen...

      Second, "In theory there's no difference between theory and practice. In practice there is." If you think you can use any methodology in a brain-dead, just-follow-the-rules kind of way, reality is going to slap you, hard.

      But, third, XP is not really rigid. You're supposed to adapt it to your environment, conditions, personnel, etc. So if you are trying to do XP in a stick-to-the-rules way, you're not really doing XP...

    24. Re:Extreme Hogwash by Anonymous Coward · · Score: 0

      You claim you were fired. I assumed in order to be fired one has to be an employee. My mistake.

    25. Re:Extreme Hogwash by roman_mir · · Score: 1

      I'm sort of neutral about XP still. My take is that almost all the ideas are good, but implementing it in todays business world is virtually impossible. - I saw it properly implemented. But it didn't lead to good results.

      So, my question to the parent would be: do you really think that the XP practices and values were all correctly observed and implemented and that the process failed, or do you think that the implementors may have called themselves XP but actually didn't implement the entire set of practices--which caused it to fail? (I'd really like an answer because I'm still evaluating the practice myself) - I believe that XP was correctly implemented in this case, they followed all of the XP practices.

      all the User Stories were written by the customer, laid out on cards, discussed by the programmers, and had times allocated before the 4 month number was given? This alone would cause the project to fail, even if everything else was 100% XP. - The client was always present during the user stories creation, every user story was confirmed. This client/vendor had an advantage even, because they have gone through the same process a year earlier.

      If the original user stories actually tallied to 4 months (by programmers estimates), were a significant portion left as "removable" so that there was some flex in the schedule? - there was some flexibility in the schedule from the beginning. All of the user stories were mandatory, but it was possible to shift the release date by about 2 months maximum (by this sacrificing the final SIT time.)

      Did you notice programmers activly switching off, constantly re-aranging pairs (each engineer should have at least two different pairs a day) and having nearly constant bullpen discussions? - we had everyday standup meetings, we switched/rearranged pairs about once every week. The discussions were taking place very often (whether at predetermined times or whenever someone felt it was necessary.) My personal feeling about this is the following: if there was an overal architecture done prior to the project, many of those discussions would have been unnecessary, more time was wasted going back and forward between different solutions to the same problem, and at the end really, any of the discussed solutions would have lead to the same results.

      Was there a customer and a QA representive in the core group--appearing at each stand-up meeting and discussing design issues? Was the QA rep. designing and implementing approval tests from day 1? - yes.

      Was there complete visibility? Every week the customer should have known EXACTLY how long the remainder of the project would take. Every week the estimate should have gotten more accurate, not less. The customer MUST look at the story cards on the wall every day (at least during the standup meeting) and notice how many are going to be done next week, how many weren't done last week, how many still haven't been moved into the "Active" category, ... How could it possibly have gone so wrong with constant feedback and cutting of user stories? - the story cards and story progress was evaluated often, however I personally believe that the estimates got more and more blurry, not clearer. The proposed solution became too complex (which was easy to predict from the beginning, building business requirements is not the same as building all of the frameworks needed to run those requirements.)

      So with all of the transparency, the actual task grew every day not because of the user stories themselves, but because of all of the supporting infrastructure that had to be built. Again, if there was a design done originally with the major features but also with all of the frameworks being discussed, this problem would have became apparent. However, due to the pressure to keep as close to XP as possible (I have never witnessed a closer approximatoin of that process in 11 years,) the architecture was not done and these 'details' got hidden.

      Is ther

    26. Re:Extreme Hogwash by roman_mir · · Score: 1

      As a contractor one does not get fired, the contract is terminated prematurely. However this is just a technical difference. The next morning I was already working for IFDS. The vendor was removed from the project about 3 months after I left, the project continued with internal people only. Instead of the original release date (July 2004) the project was released about a year after that. Certainly the business behind the project is sound, and what ADP is doing with that business deserves a reward (whatever it is.) I am not talking about the business of ADP, I am not talking about the vendor even, I am talking about the methodology in question and the fact that the project was about a year late.

    27. Re:Extreme Hogwash by bill_kress · · Score: 1
      I agree with a lot of the stuff you are saying, and I can see your frustration in the way your project went.

      The stinky code would get refactored more than necessary, the excellent code would remain mostly untouched. The difference is this: who provides the original code.

      I absolutely agree, this is a huge factor with any project. As I understand it, Pair Programming is all about ensuring that an experience programmer is looking over the shoulder of the new programmer helping him, and when you get a pair of inexperienced programmers, an experienced one would come along behind and refactor.

      Even an average architect would have predicted that building all of the frameworks in house is detrimental to the project and to the business.

      Anyone should be able to see that an XP team cannot "Pick" an architecture (purchased frameworks, etc). That is up to the customer or manager to do before the team even becomes involved. There is nothing in XP that forbids any design, in fact, in kent's book, he says you need to do an appropriate level of design (if I recall correctly), just like you should have an appropriate ammount of comments (That's a pet peve about "XP" code I've worked with).

      If an "XP" team pushed you saying you were being more "XP" if you built everything in-house and didn't even look at external tools, than shame on them for using XP as a lever in that way and shame on you for letting them do so against your better judgement. Again, this is my biggest problem with XP--it should not be used as a tool to avoid doing a certian type of work, it's more about ways to re-arrange the work that might be more efficient.

      The following quotes of your all indicate that the company you were contracting with was not really understanding XP:

      The client was always present during the user stories creation, every user story was confirmed. This client/vendor had an advantage even, because they have gone through the same process a year earlier.

      To say the client was present implies the engineers created the user stories. This shouldn't happen.

      we switched/rearranged pairs about once every week

      This statement shows a team that doesn't know what pairing is about. Pairing shouldn't be continuous and nobody should say "now we Switch", it's more about grabbing someone to help you do a task a couple times a day (which implies that there should generally be resources available that are NOT paired.)

      Not that the ammount of time is any big deal, but to have a time where we say "Everybody switch pairs now" means somebody really didn't get it.

      there was some flexibility in the schedule from the beginning. All of the user stories were mandatory, but it was possible to shift the release date by about 2 months maximum (by this sacrificing the final SIT time.)

      This sounds a lot like a traditional project and nothing like an XP project.

      there was almost no late nights, but everyone got the CTS. One person at the computer had to provide the code that two people would generally provide during the day.

      You are supposed to switch back and forth every few minutes. This keeps both programmers awake and provides a break. That's the whole point of pair programming! What on earth were you doing, one programms while the other naps in a chair behind him? I'm surprised the entire project didn't crash and burn. Oh, wait...

      Actually I believe this is another huge waste. Had the framework architecture been defined before the coding started, the refactoring would have been minimal.

      Then why didn't you do so? XP is not a replacement for common sense or the ability to understand your project--and don't let people beat you over the head with the letters "X.P." to force you NOT to do something that you know needs to be done.

    28. Re:Extreme Hogwash by roman_mir · · Score: 1
      I absolutely agree, this is a huge factor with any project. As I understand it, Pair Programming is all about ensuring that an experience programmer is looking over the shoulder of the new programmer helping him, and when you get a pair of inexperienced programmers, an experienced one would come along behind and refactor. - that would make sense if it only were the case that experienced programmers are paired with inexperienced programmres, but in our case most programmers were experienced and we still wasted half of the development capacity by pairing everyone. Tell me, what is the point pairing two developers, where each one has more than 8 years of experience?

      My opinion is that pairing can be used to bring a newcomer into the team, or if there are not enough computers (a stupid situation.)

      --

      Anyone should be able to see that an XP team cannot "Pick" an architecture (purchased frameworks, etc). That is up to the customer or manager to do before the team even becomes involved. There is nothing in XP that forbids any design, in fact, in kent's book, he says you need to do an appropriate level of design (if I recall correctly), just like you should have an appropriate ammount of comments (That's a pet peve about "XP" code I've worked with). - One of two things can happen: the vendor in question is trying to become irreplaceable, and thus is set on developing everything in house. The client is being unreasonable and is not willing to buy/use free frameworks. In the first case the vendor can use XP as a masking methodology, by not bringing these facts to light upfront. In the second case there is not much that the vendor can really do.

      If an "XP" team pushed you saying you were being more "XP" if you built everything in-house and didn't even look at external tools, than shame on them for using XP as a lever in that way and shame on you for letting them do so against your better judgement. - go to the beginning of this entire thread and reread my comment on my involvement with the project. From the very beginning I was voicing my strong opinion against this entire approach (building everything in house.) I cannot really say who was the culprit, the client or the vendor, making this kind of a decision. From my point of view XP allowed to cover up this obvious to me problem from the beginning.

      The following quotes of your all indicate that the company you were contracting with was not really understanding XP: - not true. Go to that vendor's site and read on their 'culture'. They run 'JUMP tutorials' for kids, they run XP Toronto user group, they contribute to open source Amakihi project, etc. Some of the smartest people I know work for that place and they are really evangelistic about the entire XP methodology. I definitely think they are one of the top XP people around.

      The following quotes of your all indicate that the company you were contracting with was not really understanding XP:

      The client was always present during the user stories creation, every user story was confirmed. This client/vendor had an advantage even, because they have gone through the same process a year earlier.

      To say the client was present implies the engineers created the user stories. This shouldn't happen. - I did not imply such a thing. The clients were always present and active. Who exactly created what I am not going to get into those details, because I was not always in those meetings. But the client was completely active and if the vendor did provide plenty of input into the stories (this was second iteration of the project after all,) the client always had the final word.

      we switched/rearranged pairs about once every week

      This statement shows a team that doesn't know what pairing is about. Pairing shouldn't be continuous and nobody should say "now we Switch", it's more about grabbing someone to help you do a tas

    29. Re:Extreme Hogwash by bill_kress · · Score: 1
      I'll answer your question because you asked it. You have been very helpful, I think I got a good insight from you and I'm sorry if I frustrated you some, it was not my intention. I won't expect a reply.

      The kind of design XP is eliminating is the design where you go down to the method signature level on every single class in the project. - XP with upfront design is not XP, that's the idea, never think ahead, or you are not following the XP method. Your comment on signing every single class in a project is preposterous. Can I ask a personal question? Have you actually worked on a single real life project? If yes, have you ever worked on a single life project where it was a requirement to sign every class?


      First of all it's not generally a requirement to design every class, just a good practice if you can pull it off, most can't. Haven't you heard that design should take 60-80% of the development time? What did you think those people were doing? Designing to object/component level? That would take maybe 20% of the time--probably not even that much--it's the first step.

      Most of the practice of requiring method (function signature)-level design went out with nasa and the big IBM style projects of the 60's and 70's, those of us who started programming in the 80's saw little of it, those who started in the 90's, probably none at all. As the number of programmers went up, the number of talented architects didn't scale, and your typical programmer 5 years out of college simply cannot do it, most never will be able to. How long do I have to paint before I can create works as good as DaVinci? How much piano practice will get me to the point where I can create a great symphony? Innate talent is a critical part of design (be it buildings, software or art)..

      On small projects I have successfully designed around 60% of the classes to the method signature level and almost all of the structure of the new database and data transfer systems for an existing system, but that's only spending two months to design a project that, say 10 people implement in 2 months (Very Small Project) which comes to about 10% of the project being spent on design, not 60% or 80%. Typically we came in before or near my original schedule (doesn't necessarily have anything to do with what the customer wanted or what our sales staff had promised, but was always made available).

      If I had spent 60% of the project time up front, I could have gotten closer to, say, 90% of classes designed to method signature level, and I think the whole project would have gone much better.

      All the problems we encountered on that particular project were areas that seemed easy enough to me to go without design, so I only designed them at a high level (Object level, or one object representing a group of objects). This caused two problems, one is that they weren't that easy (As you delve in towards the signature level you always discover splits and confusing areas that increase the complexity and I was still learning that), the other is that leaving programmers without guidance is problematic--it needs to be compensated for by a lot of mid-project design discussions and significant refactoring. (When you eliminate the design altogether, it all becomes mid-project design discussions and refactoring)

      On a difficult project, to design to that level takes a handful of Good Architects and a small team of designers acting as architects and a HECK of a long time--it's rarely (if ever) done anymore, most shops can't have Good Architects so they make up for it with more agile practices.

    30. Re:Extreme Hogwash by roman_mir · · Score: 2

      First of all it's not generally a requirement to design every class, just a good practice - It is never a requirement to design every class. It is not a requirement and except for academic tasks it is never done a practice (I exclude extreme cases, such as NASA, because I cannot really say much about those.) It is a requirement to describe the behaviour and external interfaces. If complex algorythms are needed, then it is the job of an architect to provide them either as a design (a flow-chart for example,) or as a library requirement.

      We describe structures and we can use components/classes/interfaces/object/package diagrams for that, we describe behaviour and for that we can use collaboration/sequence/timing diagrams, we describe behaviour and for that we can use activity/state/use case diagrams. We can use any of the abovementioned diagrams but it is not a requirement to use them, you can just as well describe in words the entire design, but pictures help most people.

      When I say architecture I don't just mean design of the classes/interfaces/data structures/behaviours. I mean a review of the requirements and a discussion on how the requirements will be met within the project. The actual details of the implementation can be left to the developers (and in most cases should be,) as long as the general patterns of development are made clear, the frameworks are accounted for, the components are identified, the major tasks are established and all of the more complex algorithms are overviewed. The architecture must take into account all of the MAJOR decisions, such as the communication methods, storage methods, scalability methods, security methods. There is more to it, but basically architecture describes components of the application and describes how the usecases are supposed to be implemented by those components. The collaboration between components must be made clear with the interfaces.

      The architecture must take into account the hardware, the security and the legal requirements of the system, it must take into account performance expectations.

      The architecture must express the totality of the application as the sum of all its parts, and each part must be accounted for, thus making it possible to give a close enough time estimate for implementation of each part.

      The architect must take responsibility for identifying all of the major system components and interfaces.
      The architect must take responsibility for reducing the system components into smallest individual building blocks.
      The architect must have experience making time estimates for smallest individual blocks.
      The architect must know the team. If this requirement is not met, the estimates cannot be very precise and must be padded for the unknown variable (some people work better than others, some people are known to have done a similar job in a specific known time period.)
      The architect must keep up with mostly inevitable business requirement changes.
      The architect must insist on a particular set of development standards.
      The architect must insist on a standard set of build/deployment procedures.
      The architect must insist on a standard method of unit and integration testing.
      The architect must insist on a standard method of source code management (cvs with locks or whatever.)

      This is probably not complete but it is what I came up with in these 2 minutes and probably covers most of the work that the architect is responsible for. The architect is mostly a technical manager with authority to resolve conflicts and with responsibility to prevent time wasting.

  39. XP makes improvement possible? by DragonWriter · · Score: 1

    So, no improvement ever happens without XP? Somehow, I doubt that.

    I think this goes beyond "extreme" to "hyperbolic".

  40. The case for thinking for yourself by zenwrench · · Score: 0

    Maybe you follow the commandments of XP to the letter, maybe you spend countless hours in waterfall meetings ... regardless, I think considering XP, if nothing else, makes software development's collective weaknesses more apparent. I'm not saying that XP solves those problems. Instead, it just throws them into a sharper relief.

    And in the sense that XP *does* propose a solution ... well ... my advice (coming from a relatively competent programmer and project manager) is learn to think for yourself and to constructively pressure your management for the latitude to experiment.

    XP makes some good points ... but to be fair, I've felt like a walking buzz word whenever I've attempted to pitch and/or defend it. If I could change one thing about it ... I'd change the name. What's next ... Pimp my Test Harness?

  41. Programming != Software Engineering by SquareVoid · · Score: 1

    Please don't confuse the two. XP is a process only, and it is to be implemented for programmers. Software Engineers design systems and plan out the project which programmers will use. Software Engineers also choose to use XP or other better suited processes.

    Now, I am not against some of the agile methods out there, but XP is all hype. The only people who have gotten the process to work aren't really working on real-time systems, or an operating system, or any porject that is of significant scope.

  42. Sounds like writing management books by wasted · · Score: 2, Funny

    A lot of business management books work that way.

    1. Take something obvious or counterintuitive (Doesn't matter if it will really work or not)
    2. Label it with impressive sounding phrases
    3. Copyright a bunch of specific steps (methodology) to do the obvious
    4. Write and publish a 400 page book about the methodology steps using your new phrases
    5. Sell it to PHBs and incompetents
    6. Profit!
    7. When complaints about non-success arrive, arrange seminars at hundreds of dollars per seat.
    8. Give Seminar
    9. More Profit!

    Hmmm, since I have all of the steps down, maybe I should write a book...

  43. Mostly, XP improves Kent Beck's net worth ... by joe_n_bloe · · Score: 2, Insightful

    Having been through employers who tried both XP and Scrum (not Beck but similar), the only positive thing I have to say about either is that if your developers really suck, teaching them XP and/or Scrum will allow you to keep much closer tabs on their lack of progress. Otherwise, like most "new" methodologes, it's a way for people to teach classes and sell books.

    1. Re:Mostly, XP improves Kent Beck's net worth ... by leshert · · Score: 1

      I suppose when you're an author, everything looks like a way to sell books.

      My experience with XP at a previous employer was positive. Maybe that's why I'm not writing books.

    2. Re:Mostly, XP improves Kent Beck's net worth ... by joe_n_bloe · · Score: 1

      The reason you don't write books is that you don't have anything to say that anyone wants to hear.

    3. Re:Mostly, XP improves Kent Beck's net worth ... by Anonymous Coward · · Score: 0

      That apparently didn't stop you....

  44. Got a Life = Declining Productivity [Laundry?] by joe_n_bloe · · Score: 1

    The problem now is that all the good developers from the 90s are married and enjoy spending time at home with their rugrats, and have the "just a job" mentality. You know, go to work, work, go home, don't work.

    They've got some nerve.

  45. Re:Overrated == Someone answer this by Mikkeles · · Score: 1
    'They use analytical methods, which are fine and efficient, but which are nowhere near formal methods as I know them.'

    These are exactly formal methods: a description of the design as a collection of mathematico-logical relations which, when solved, indicate that (in structural designs) the stresses and strains (deflections) do not exceed specified values.
    Testing generally consists of checking that the parameters assumed (e.g., 28 day compressive strength of the concrete) are correct. The relations are normally checked directly against strength of materials only for new and inovative designs (e.g., thin shelled concrete designs, though they are now much more common than when I last dealt with this.) There will also occasionally be load tests performed, especially if unexpected cracks appear!

    --
    Great minds think alike; fools seldom differ.
  46. extreme-ly lame by not+a+cylon · · Score: 1

    "Extreme" has lost its meaning in the same way that "Alternative" has. And pair-programming has always been eighth-grade gay, no matter what anyone says.

    Test-first? Yeah, sounds great on paper. In reality, it gets steamrollered by feature requests. And besides, no one really cares if the software works or not, because if it doesn't, it just gives the user an excuse to not work for the whole day, or to take an early 3-day weekend. (at least for most software. the statement probably doesn't hold for users of medical or avionics software.)

    The current state of programming is more like finger-painting than engineering. It's messy, hands-on, and only a mother could love the results. And it is performed by children dressed up in the bodies of adults.

    The solution? Simple. We only need to be just clever enough to figure out how to implement AI. Then we can let the machines take over. Let *them* figure out all the hard stuff, so we can get back to playing WoW. And I for one will welcome our new programming overlords.

  47. Re:Overrated == Someone answer this by aaribaud · · Score: 1

    The key lies in the "specified values". For any "real" engineering, you'll have those arbitraries in formal methods. OTOH, formal methods in SW engineering do not suffer arbitrary matters. SW-related 'formal methods' carry a specific sense of *absolute* correctness while the 'formal' methods described here for, erm, 'concrete' engineering do not.

    If you want a SW equivalent to what you name formal methods (and which I have been taught to call mathematical or analytical methods, but not formal), then you should look into SW metrics. They also have a mathematical structure, and also carry adequate arbitrary constraints, e.g. 'cyclomatic complexity should remain below 7' or whatever.

  48. Re:Overrated == Someone answer this by Mikkeles · · Score: 1

    They are not arbitrary, they are the properties of the building materials. In the same way, there is no absolute correctness in the SW formal methods; it depends on the questions asked. For example: a proof that communicating threads never deadlock. Absolute correctness would imply that the code is both complete and consistent, completeness being the tricky part. Normally, the code can only be proved viv-a-vis a specification, which is mostly arbitrary, but must be consistent.

    --
    Great minds think alike; fools seldom differ.
  49. XP in the University by icub3d · · Score: 1

    I enjoyed XP while working at school until I realized that they were just using me to get good grades. Putting it the workplace gives way for the unresponsible to jump on the coat-tails of the responsible.

  50. Re:Overrated == Someone answer this by Peter+La+Casse · · Score: 1
    As a non-layman, highly SW-based, real enough engineer (and other than that an almost normal person), I would not parallel, for instance, structural analysis in civil engineering with formal methods in SW engineering. "Formal method" is the name of a specific kind of SW analysis tool, based on mathematically proving the software, not taking stress scenarios into account (stress simulation for SW is called "testing" :) ).

    There are tools to help with formal methods, but don't mistake the tool for the method. It's simply the case that without their tools, formal methods are impractical on nontrivial systems. The parallels that I was thinking of between formal methods in software engineering and mathematical calculation of loads and stresses are these:

    1. Both can occur during planning or design, before something is actually built
    2. Both use mathematically rigorous techniques
    3. Both can be thought of as a system of equations

    Do you believe that software engineering is real engineering? I'm open to the idea (that's its goal), but I see a huge discrepancy in quality of results.

  51. Re:Overrated == Someone answer this by aaribaud · · Score: 1

    The three analogies you draw are correct, but they do not allow concluding to identity. As I pointed out, loads and stresses are necessarily based on experimentally measured input (e.g., IIRC, the Young modulus) while formal SW proof methods have no experimental pseudo-constants involved.

    Apart from that, yes I do believe SW engineering is truly engineering, and at the same time, just as I would say "painting is an art, yet only few paintings are", I would partly agree that current software quality is awfully bad. But partly only.

    While a fault in a bridge design will only affect the designed bridge, a single fault in some software will induce errors and misbehaviours in every instance of the software, more so if the software is in very common use, thus faults in somesoftware are more likely to get bad publicity.

    Now software is not the only thing that gets mass-produced and therefore not the only kind of product for which a design flaw will induce a massive count of errors, yet it seems like it does actually fail much more than, for instance, TV sets.

    One (among several) reasons is that, while only few bridges are engineered by people without a sound background in civil and mechanical engineering, software frequently gets done by people with less-than-perfect skills (you don't get a rookie to build a bridge, do you? Well, you can get a rookie to write code).

    The SW engineering field is real engineering alright... but many SW designers are not engineers.

  52. An observation about XP by itsNothing · · Score: 1
    I worked on an XP project a couple of years ago. Towards the end of my involvement, i found a quote that summed up the XP experience:
    Weeks of programming can save hours of planning
  53. Pairing is fun by dubl-u · · Score: 1

    I actually found it far more tedious and mind-numbingly boring then dedicated code reviews myself.

    Were you sitting with equal access to the screen and keyboard? Was control changing hands at least every ten minutes, and hopefully every five? Were you doing test-driven development? If not, I'm not surprised. Done right, I think it's much more fun, and much more productive.

  54. XP certainly does make improvement possible. by bergeron76 · · Score: 1

    It shows people why they should use Linux or OS X.

    duks

    --
    Don't think that a small group of dedicated individuals can't change the world. It's the only thing that ever has.
  55. Holy water and crosses aren't good enough by ClosedSource · · Score: 1

    I get sooo tired of hearing that xxx is not a silver bullet, but it's really great and we should all use it anyway. We have plenty of holy water and crosses, if you don't have any silver bullets today please don't come back until you do.

  56. Here's one more word: by Anonymous Coward · · Score: 0

    evolution