TXP (Traditionally Extreme Programming)
Vishal Saberwal Computer Science Department, California State University, Fresno CA 93740 USA vishalcyberwall@csufresno.edu, +1-559-681-6745 | Tarek Alameldin Computer Science Department, California State University, Fresno CA 93740 USA +1-559-278-3965 |
International Conference on Software Engineering Research and Practice (SERP'05)
3
Abstract
Traditional approach has been talked about as too manufacturing oriented and an old technology that cannot suffice with the increasing market pressure. Also, lots of talks have been published on XP, naming it the next technology leading to far better products while working under the market pressure. This paper introduces a TXP (Traditionally Extreme Programming) approach to Software engineering that is a transition bridge from Traditional to XP.
“Is the time right for Extreme Programming?”
When I use the word “Time” in this question, what I mean to ask is, “Is the industry ready to use Extreme Programming (XP)?”, “Are the developers ready to adapt to this new technique/approach to Software Engineering?”, “Do the developers/Programmers/Management have enough skills and knowledge to implement the Extreme Programming Approach?”, “Is there a direct shift possible to Extreme Programming?”, “Would Extreme Programming really solve almost all, if not all the problems in Traditional Approach to Software Engineering?”, “Though it sounds great and logical on books , but is it too ideal to adapt or is it really practical?” and such other questions that would cross a Software Engineer’s mind. Though I could have chosen one of these questions for my project report, but I wouldn’t have been able to give overall picture of what I am proposing by writing the report. I am evaluating the Traditional Approach and Extreme Programming Approaches (shown to be two far ends of Software Engineering flat world) and finding a (original) solution to prove that (the world is in fact round and not flat) we need an approach that does the transition from traditional (guessing approach) to extreme. We need Traditionally Extreme Programming (TXP).
My Motivation
Having studied extreme programming in class and having done industry work in Software Engineering, I analyzed the practices we use in the industry and distinguished advantages and disadvantages Extreme programming and Traditional approaches provides us with. After looking at the differences in the two, I figured that the gap was too big to cover and still attain productivity and efficiency of software product development. I needed to extract the good from both the approaches and come up with one single solution. This motivated me to come up with my own approach of Traditionally Extreme Programming (TXP). I thought of two industries (movie and railway industry) to come up with analogies and show the benefits of this approach. Well! Couldn’t have used Software Development industry, as this is a new approach, right! I got more motivated when I read papers on the project experiments they did in different universities. Though they reinforced my question from their results, their reasoning to blame humans got me more curious and thinking. This further motivated me to further analyze their reasons and finding that they missed out on the most important reason (the human psychological factor). Just like the many theories that can be proven on paper but are not practical to do (yet!): why? Because of human factor, we don’t have right skills to do it practically. We might reach the goal of perfection, but this sure will not be done in a day but would be gradual. The supporters of extreme programming failed to tell you how to do this gradual transition from Extreme to Traditional approach. This is the area I am exploring in this project report.
Why Not Traditional? Resistance!
The traditional software engineering approach is based on Fredrick Taylor's approach developed in late 1800's and early 1900's. Fredrick, while working in a Manufacturing Steel industry, noticed a lot of inefficient practices. To increase the productivity, he came up with his "scientific management approach" by doing time and motion studies. According to this approach, one would time the person at work and then try to figure out the most efficient way to do that work. This approach did revolutionize the brick masonry and other production/manufacturing industries but the drawback was, it treated humans as machines.
The software development started in early 1950's when scientific management was really popular in the industry. It seemed reasonable then to incorporate the same practices and management strategies in software engineering industry, as scientific management was proving to be good in other industries. This brought the so-called manufacturing/traditional approach to the Software engineering. Traditional approach in software engineering is based on guesses you make based on your experience or your estimate from a similar project.
The problem with Traditional waterfall model was that, customers tell us once and for all as to what exactly is required, and most, if not all, changes would require changing the design and going back to the previous (requirements) steps resulting in lot of money and time being washed away in this waterfall. TXP solves this problem by giving the customer the flexibility to come back and ask for a different scene/patch or part and still save lots of money and time from being washed in water. This also benefits the software development company so as to have robust reference documents that actually defines the customer’s needs and design goals to reach.
Analogy: Let’s Ride the TXP Train!!!
(http://www.esj.com/enterprise/article.aspx?EditorialsID=1151) Roy Miller rightly compares Traditional approach with a Train Rail. You put your Software development train on the rail to go from point A to point B. But what if half way through the rail you find out that you are off the direction. Now you can either go back (too expensive in terms of time and cost) or you still push to reach Point C (off the direction from where you wanted to reach, Point B). This provides software that doesn't exactly do what it is supposed to.
I see another option to still reach your goal rather than compromising with Point C. How about having a few junction points on the rail; you can go back to the previous junction points, if required, and reroute the rail into the next direction. [Figure 1].
In Traditional Approach to Software Engineering, you would spend a lot of time going to Scene1 and then to Scene2 (the path might take lots of turns and loops around and is not the shortest path) and so on sequentially. How about making many rails go in parallel, each rail connected to next junction by shortest path. Now you can go to closest junction and get the next train running to the next destination on the shortest path. You can reduce the time you spend to reach point B, still following similar strategies (Time is Money).
”Analysis” of the project is my ticket center where you decide to go on a trip to Point B and check if you have good reasons and finances.
Design Stage is our Point A when we define where Point B is located (finished Software). This is a big Terminal Junction for different
rails running in parallel. As illustrated in the figure, after traveling through the Scene & Part trains and then traveling through the Patch trains, you reach your Point B in less time. This is a great advantage when compared to traditional approach, as traditional approach has no junctions, and when you find out you are going in wrong direction, it could be too late. Hence the illustrated approach of TXP has advantages over traditional approach. [Figure 1].
TXP trains do follow the traditional approach to an extent. They also have advantages of XP. Having the backward compatibility to the Software Engineering Traditional Strategies/ Approach, there is less training required for the Engine Drivers (Manager and Management) and staff (developers). Further, it’s more adaptable
and convenient to switch to. Though some advantages of XP do portray being the ultimate money and time saver, but human factor enforces TXP approach for being more adaptable, flexible and resource (money and time) saver.
Analogy: Let’s Make a Movie!!!
Who says Software engineers don’t like watching movies? Here is a trip to TXP (Traditionally Extreme Programming) Studio.
The first step is to know the goal or theme of the movie. You can decide this by doing a market survey or analyzing statistics and making your own movie (In-House Software Product). It is also possible that a customer gives you the requirements of the movie for a particular theme like autobiography, documentary (You are getting an Outsourced Software Project).
You and your management do Analysis of viability of the Project (Project will be the term I will use, when talking about this movie project and Software project, interchangeably). Once the analysis is done comes the Design stage. Let’s XP the design phase. The design of the (movie/software) project is divided into Scenes (equivalent to stories for XP). Scene1 could be emotional scene, Scene2 could be Action, Scene3 could be Suspense, etc. Many of these Important and prominent scenes based on special events/components are identified and designed. Each of these scenes is reviewed and Finalized and used as a Scene Card (similar to story cards in XP) in the deck of cards (SCENE-DECK).
The scenes are ready but what about continuity of the movie/project? This stage is the Integration Design where the Patch Scenes are designed to integrate Scenes in the SCENE-DECK. We enter this Stage/Phase only after all the Scene Designs have been finalized. For example, Patch12 will be identified as the Patch Scene that will bring the continuity/transition from Scene1 to Scene2. Each Patch is individually reviewed and finalized and then kept in a separate deck of cards (PATCH-DECK). Guess what! Now we have the Script (Design) for the project/Movie ready.
As you can see, we have used modular/XP approach to define the project into scenes. In this process, both XP and traditionally (Software) manufacturing approach co-exists. This makes it easier (for those who have been using traditional approach all their software engineering life) to start climbing the ladder (TXP) to go from Traditional Approach to Extreme Programming Approach. Yes!!! We do need the ladder.
Now its time to XP! We open the SCENE-DECK, choose the actors (Software Engineers) based on the scene requirements and skills, assign the scenes to the Actors and they start working on the scenes (Implementation) they are participating in. This provides a great opportunity for the TXP Studio (company) to know what skills they are looking for in an actor beforehand and to (hire/assign the scene) only to those with the skills.
After working on (Implementing) the Scene, the Scene is previewed (Self Test) for modifications and tracked back/compared to/with the Scene Design. This creates a prototype Scene. Now this Scene awaits approval from the chosen audience (Similar to Usability Test of a GUI).
Let’s start working on Scene3. We divide the scene into various Parts (tasks in XP) and shoot/implement the part. Then we do the Test on each part (unit test) and once all the parts in the Scene are tested, you test the Scene3. Now you have your TXP prototype Scene3 ready!!!
Patches in movies are Scenes with just fading/blackout effects, text (like “After 15 years…”), or could be a small scene with Performers/Actors. [In software engineering terms, Patches can be compared to Common header files that needs to be included in two/more Scenes, could be a Make file, a script or a Configuration file.] During Patching/ Integration, Different Components/ Scenes have to work together to provide the smooth transition without the audience (user) noticing the change. This might require different Software Engineers at different levels to come together (Systems Engineer working with GUI person).
Patches (being nothing different than Scenes that are used to patch two/more separate prominent and important Scenes), have to go through the same process of Division into Parts, Implementing each Part, Testing each Part, Testing the Patch and Prototyping the Patch and then Approving it.
Though each scene is following Waterfall model, they are producing prototypes at different times (XP approach).
Figure 1
So Patch12 brings a transition (Integration) from Scene1 to Scene2 [Scene1…Patch12…Scene2]. This brings continuity to the movie.
The movie (Software Product) is now previewed by the management and selected audience (Usability test). Once testing is done, and Movie (Software Project) is approved, you release it commercially. Now the Customers watch/evaluate it (Software Evaluation and Deployment) as shown in [Figure 2].
A Successful movie (Software Product) haan!!!
The above analogy (movie) can be compared to OOP: A Patch (class) can have Parent classes (Scenes) and Child Classes (Parts). Parts inherit properties of their parent Scene/Patch. Patch can be considered as a Friend Class or multiple inherited class.
Why not XP? Resistance!
A big project can be divided into smaller parts/components/stories, but there is still a parent child hierarchy to comply with. Though exceptions exist, most software project stories/components are sequential and interdependent. This doesn’t always allow the customer to choose a Story/Component at random. Not all software can be divided into discrete stories with no sequencing or dependencies. The Patching (Integration) is definitely required, which, I believe, haven’t been given a lot of thought to in XP. XP might prove helpful in some projects, but I do not see its implementation possible for all projects in general. Time and cost are important factors to save on, but I don’t see a direct jump to XP from Traditional programming possible.
TXP is one of the approaches, if a company implements, can prove to be successful and provide desired product relatively faster (when compared to traditional practices) and better. I learnt in school, “Entropy Exists!” in everything (Ideal doesn’t). XP assumes that all projects can be divided into separate distinct stories and looks at the process with an ideal view. It also assumes having customer on development site will always help. Moreover, having two engineers/programmers on a story/task and expecting them to know each line of code going in the implementation may be too much to ask (depending on the scenario). Also, giving little/no emphasis to documentation and taking the second programmer as a backup if first quits from the company is too ideal. What if both quit? It is always the detailed documentation on the project (with scenes and patches designed) that will help you solve the jigsaw puzzle.
Kent Beck in his paper admits that, “To try it (XP) today would require courage, flexibility and a willingness to abandon the project, should your use of XP be failing.” Roy Miller, Independent consultant, who has written books on XP, and has worked with Enron and IBM, also admits, “It (XP) doesn’t feel all that professional. You’ll get objections like “What happens if you lose one (story)? The real resistance is more psychological than methodological.”
Both say that, it’s not easy for everyone to just start using XP. Psychological reasons will exist as long as we exist, and we generally need time to adapt and evolve and it can’t happen in a day. For this pure XP transition, I see the need for TXP ladder, so that developers and managers are encouraged to use XP in a way similar to what they have been doing and then gradually move to pure XP, which has been alleged to be promising in delivering better and faster software products with great savings on time and money.
If you have a manager and he’s been taught his whole career that he’s got to make plans the traditional way, with his busy schedule, it’s hard to suddenly adapt and get trained for a XP to do projects. I believe, the supporters of XP failed to see a need for transition strategy and though they distinguished the Psychological problem, I didn’t find any papers that tried solving it.
Quotes from various papers say that, not everyone can use XP practices and it isn’t easy and needs extra effort, so what we need is a transition so that its gradual and easily adapted (TXP can be easily adapted as this approach is similar to traditional practice with XP blended in it) with little or no training.
XP has more of an attitude of get it done and get done with it. To keep up with the pace of technology, the TXP approach gives you defined goals and flexibility to go to a previous stage (junction) if the technology changes. It is better than traditional approach when finishing the design on, for example, LCD screens for News display when they come out with paper-thin e-newspapers. TXP is safer since you know beforehand what components you have to design (just like in XP), plus, how would they fit together in Jigsaw puzzle. Having a clear and defined design/goal is a great motivation and not just picking up the stories and attaching them just to be surprised as to what u made when the product is ready. Knowing the goals beforehand brings confidence and enthusiasm in the team and organization. Though the prototype will take some time to be done but the product will serve a better technology and be better defined in the document than in XP.
Yes, you can build on the previous design integrating at the same time but it’s not always the scenario. You divide the work, within your team, into modules: each group/individual doing their module. This brings out the integration issue. So why not just see how these pieces go together in the design stage than finishing the 10th story and then find out oops! the first story code is not compatible with the 10th and then redesigning and reintegrating the rest to suite the purpose or rethinking other alternatives.
(a) Customer On-Site!
Do we actually need customer on site? Well! Some would say yes and others would say no, may be it depends. Having a customer is an extra cost to customer and the software development company. It has to provide space, time and resources for the customer on-site who would have to be present through out the life cycle.
A customer could be uncooperative, or hard to understand or hard to communicate with. Such social factors or issues would play an important role in successful completion of project. Also, the possibility that not one customer might have the knowledge of all the stories brings in a new customer and new human/social or communication issues to solve/resolve. With TXP approach, there is no necessity or rule for a customer to stay on-site. He can visit, take part in scene designs (if management and customers agree) and approve prototypes when they are done. Just as XP, in TXP, customers can prioritize the scene completion and prototyping.
Figure 2
(b) Pair Programming!
Imagine you write a few lines of code and then explain it to your teammate. Now, he starts writing some code and then explains you what he wrote. You both may make notes and keep track of them, but do we have a single document in which they both are writing the notes? Do you think, it is taking more time than required? It is a good strategy to have two programmers to be working on the same task, and having a backup if the other leaves/quits. But, what if, both quit? What is the probability that both understand each other’s explanations and contribute to the project? Is XP assuming ideal relations within these teammates or is there a possibility of social issues here? In TXP, even if the programmer leaves/quits, we do have design document to take refuge on and hire someone for that particular scene implementation.
(c) Continuous Integration!
In XP approach, new story/code is integrated into the system within a few hours. Suppose, you do this continuous integration: Starting with story1and then adding story2, then story3, then story4, then story5 and then story6. Again assume the order of the stories integrated above (1-2-3-4-5-6) is required for the software end product. Now customer comes back and asks you to change the story2 (use wireless instead of wired protocol, or use paper-thin e-newspaper instead of touch screens, for example) what do you do?
Is it really the right time to use XP?
Referring to a study done at Santa Clara University to compare Traditional and XP approach to software engineering (http://www.cse.scu.edu/~atkinson/papers/xp-03.pdf) (Proceedings of the 4th International Conference of Extreme Programming and Agile Processes in Software Engineering, May 2003) projects, the conclusion was pretty interesting.
They saw social problems within the teams working with XP. Though they blame the customer and the instructor for the results, I believe it’s more than that (psychological). Though it sounds great and promising to use XP, there are psychological and social issues, which are not thought of. This experiment did throw more light on the issues with XP. I believe TXP would be a better option to give a definite goal for software projects, yet bringing out prototypes in a relatively short time. Some issues pointed are, “Difficulty with the concept of collective ownership”, “Lack of confidence that the features completed were actually finished, producing confusion”, “Sloppy and difficult to use user interface” and “Exhibited significant failures”. The report also makes the statement, “Traditional teams delivered more features (equivalent to all eight stories, when XP delivered three of eight) but less robust code”. What I infer from this experiment is that both XP and Traditional approach are at extreme ends of the bridge, we need the advantages of both XP and traditional approaches to software engineering (TXP is the answer).
Another paper (http://www.ipd.uka.de/mitarbeiter/muellerm/publications/edser02.pdf) evaluates Extreme Programming from Economics viewpoint and finds the scenarios in which XP would be better than conventional/traditional approach.
After evaluating the two approaches using a hypothetical project, the paper concludes that, “XP does not provide an advantage if you can subdivide the tasks to be assigned to more developers” and “Advantages of XP diminishes more with decreasing market pressure”. Hence if the project has lot of market pressure, then XP is alleged to be a better choice to release prototype or partial versions of the product. Name it as Extreme Manufacturing, Extremely Traditional Programming, Extreme Software Production or anything else; TXP is the way to go! Perhaps, it’s not the right time yet to jump to XP. Perhaps, it’s time to start a transition to XP (TXP).
Question crossing your mind
I don’t think it would be right to say that TXP will abandon waterfall model, but yes it has a different approach to Software engineering. Yes, Waterfall is the basic model, but we have to grow on/from it. TXP is easier to adapt because it has similar concepts to traditional, yet has advantages of XP. So should the new generation software engineers get started on XP avoiding the transition or do they need to do the TXP? Its like saying lets take a project to go to the star to this constellation on the far end of the universe. Hmmm! May be not. A software engineer would try going to moon, then to other planets in our solar system and then further close to closest star and hence move incrementally to the constellation. It is this gradual shift that I am looking into. Further no one has proven that XP is “The Right Approach”, so I don’t see why a new software engineer be emphasized on learning XP instead of going through the basic with some flavor of XP (TXP).
Conclusion
TXP provides clear goals with design phase for the project at the same time applying XP to create prototypes. It’s easier to adapt and understand the TXP approach with less/no training. It can work on large and small systems, under high or low market pressures and can deliver quality directly compared with XP. Hence I strongly recommend TXP approach. Be a TXP Engineer!
References
I. Comparing Extreme Programming to Traditional Development for student projects: A Case Studyà John Noll and Darren Atkinson, Santa Clara University.
II. Extreme Programming from an Engineering Economics Viewpoint: A Case Study à Matthias Muller and Frank Padberg.
III. Embracing change with extreme programming: IEEE Computer à Kent Beck.
IV. Agile Software Development Maximizes Project Rewards: An Interview (ACM) à Roy Miller.
V. A Comparison of Extreme Programming to Traditional System Development Models (http://www.tamut.edu/~dreavis/syllabus/2003Springl360/APA%20Paper.htm) à David Reavis.
No comments:
Post a Comment