Saturday, December 19, 2009

MatchTalk



                           

 

 

“MATCHTALK”

VOICE ENABLED WINDOW MANAGER

International Conference on Computers for People with Special Needs,

CPSN’ 2005

 

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

tareka@csufresno.edu,

+1-559-278-3965

Director Russ Perry

California State University, Fresno

2320 E. San Ramon Ave, Fresno,

CA 93740 USA

russ@csufresno.edu,

+1-559-681-6745



 



Abstract

This paper tries to find solutions to these questions by enabling a Window Manager with Voice Output.

Sit in front of you computer and close your eyes. How would you know what is being shown on the computer screen? Even if someone tells you what you have on the screen, would you be able to imagine or understand it? Would you know what colors you have on the screen or what graphics are being displayed? Would you be able to use the mouse: Would you know where you are moving your cursor? What if someone takes the monitor away: would it cause any difference to you having your eyes closed? How would you read your online news, your papers, and your emails?

 

Keywords

MatchBox: A suite of tools for the user management of X11 Applications.

Festival: A general framework for building speech synthesis systems.

Window Manager: A program that manages a graphical user interface, determining the appearance of windows and determining the response to operations such as clicking on the desktop.

 

Introduction

This paper conceptualizes the idea of a Window Manager for the Visually Impaired. If you cannot see a Window on the screen, how do you operate a modern computer?

The paper explores the capability of Window Manager with Voice output. The goal is to be able to navigate already created applications using only the keyboard and no screen (Voice Output only). The goal of the paper is not to create a different interface, but to make it possible for visually impaired to use the existing ones.

The developed system’s interface has proved to be useful for visually impaired people. The system was named Matchtalk.

 

Overview

The paper is divided into five sections. The first section explains the system configuration used to develop the system. This section also gives a brief overview of the packages that the system depends upon. Section two provides with the information on the steps taken and goals achieved to achieve the system’s functionality. This section also describes the underlying API (Application Programming Interface) that has been developed on and used. Section three gives details on the developed system’s code and explains the constructs. The system was tested for visually impaired and their usability tests are described in section four. There are a lot of advanced features that if implemented, will create great applications to assist visually impaired. Some of these future advancements to our system are discussed in section five.

 

1. System Configuration

The developed system is Linux based computer with Festival text-to-speech package and the MatchBox Window Manager. The developed system is portable to the handheld computers. Our developed system is configured for voice output.

 

1.1. Matchbox

MatchBox has been developed over the past 3 years. This Window Manager is designed for pocket type computers. It is a suite of tools for X11 user management on PDAs.

 

Matchbox’s Window Manager maximizes application windows to maximum display size, thus viewing only one at a time. The user navigates through these windows by clicking on a dropdown list on the window title bar.

 

Since it was designed to be used on PDAs, it is small in size, fast, easy to understand and flexible. It is written in C and is very well commented.  It facilitates an environment for arranging and manipulating applications in a graphical environment. All these advantages for an open source window manager made it suitable for our system.

 

1.2. Festival

Festival is part of the work at Carnegie Mellon University for advanced speech synthesis. It provides the capability to build new voice using its internal constructs.

 

Festival offers a text to speech synthesizer to create speech. It supports a number of APIs: for shell, Scheme, a C and C++ API library and an Emacs interface. It also provides multi-language support.

 

Festival is designed as a speech synthesis system for at least three levels of users: those who want high quality speech from arbitrary text with minimum effort, those who are developing applications and wish to include synthesis output, those who are developing new synthesis methods. The developed system falls in both the first and the second categories, for providing high quality speech with least effort and enabling window manager and its applications for voice output. These advantages provided by an open source text to speech synthesizer made Festival suitable for our developed system.

 

2. Project Planning

The project was easy to achieve and the results could not only be seen but also heard. The following were the steps I used to achieve the project goal:

·       Prototype computer was installed and configured with our system requirements.

·       An event list was created and the system was designed and analyzed. The test cases were written.

·       An API library was designed and implemented as an interface between the Window Manager and the Text to speech synthesizer.

·       The portable system was implemented and packaged with desired code and installation scripts.

·       The complexity of voice tags were increased and incorporated in the optimized code.

·       The developed system was tested on the prototype computers.

 

The developed system did not need a mouse or a monitor. Currently our system needs keyboard for keyboard events for corresponding voice output.  The test prototype would consist of a Computer and a keyboard. This in future will be replaced by voice recognition system requiring no keyboard, mouse or a monitor.



We had various options available for a window manager for the development. Microsoft Window manager and XWindows [1] Window manager were the two prominent options. Microsoft has all their code hidden, thereby provided the least flexibility to change or customize the window manager to our system’s needs. XWindows has open source code and hence can provide an insight to how the windows and events are being managed. XWindows has a big array of applications written to run on it. Though it had all the features needed, the code size and architecture was complexand may require a lot of processing resources on handhelds for our system applications.

 

The looks of Window manager did not matter. We needed a window manager because applications are written using windows. This provides easy management for the windows and easy control of the events in object-oriented architecture. The system needed a Window Manager, which is fairly small, has an open source and supports many applications.

 

MatchBox Window Manager being made for Palmtops/Handhelds, which has space as a limiting factor, was small, easy to understand, and supported all applications running on XWindows. Since, this windows manager was made for Linux, we chose Linux as the base operating system for our development project.

 

The Text-to-Speech synthesizer for our system needed to be open source, for configuration and modification flexibility; reasonable in cost, and one that is under progressive development.

 

Festival, [2] a text-to-speech synthesizer was being developed in Carnegie Mellon University. It was under development to incorporate speech recognition, which would satisfy MatchTalk’s proposed future needs. Further it had a C Application Programming Interface available to extend its use to suit our needs. It satisfied all our requirements and hence was suitable for the MatchTalk system.

 

The window manager had to be modified to suit our needs. The voice tags were enabled for various components of the window manager. Then designed keyboard events were mapped for shortcuts to tasks like opening main menu.

 

The directory structure was created and install and build scripts were created. MatchTalk finally started talking, rendering voice outputs corresponding to the events generated on the system.

 

2.1. Window Manager Understanding

To make the window manager talk, first we need to understand the flow of events and actions.

Matchbox is an Event based Window Manager. The Window Manager starting point is main.c. Initially a new window manager (wm) object is created by calling wm_new(). This structure object stores the environment and information for the system it is running on. This loads up any user configuration data using wm_load_config() from command line parameters. Various wm X11 parameters are then initialized and a new wm object is returned which is used throughout the program to manipulate and control the window system.

 

After taking care of the windowing system for the matchbox window manager, the program enters its main loop, wm_event_loop(). Here it captures system and application events for configuring or performing requested/required actions.

 

When a new client window appears, MatchBox receives a notify event for the new window and a new ‘Client’ object is made for the new window by wm_make_new_client(). This decides the type of client object to be initialized (Application/Dialog/Panel window).

 

All created client objects are stored in doubly linked list referenced by pointers in Wm structure.

 

Once a client object is created, ewmh_set_allowed_actions() sets client variables to Window Manager properties. Suitable client geometry is calculated by calling client’s configure (). The client window is then resized and positioned to fit MatchBox style. The client’s show () is called which then displays the client.

 

While the client is runing, it will generate events, which will be sent to client’s methods and will be managed.

 

Key presses are monitored by wm_handle_keypress(), which searches for the relevant action defined in keys.c.

 

Button press event are be handled by wm_handle_button_event(), which will get the location of the button press and may call client’s button_press() if required.

 

The file client_common.c takes care of button management. The files above were modified to suit the project needs.



Festival incorporation into the program is done using the file fest.cc. This file uses C API to program voice output for the text. These functions defined in the file have been extensively used wherever voice enabled output was desired.

X messages for MatchBox are handled by the function wm_handle_client_message() before being sent to ewmh_handle_root_message() for the root window.

 

3. The Application

Now after having an understanding of how Matchbox works, an Interface File is created to communicate with Window Manager and Festival.

The ‘C’ API for festival is used to create this file.

 

/* fest.cc : Made by: Vishal Saberwal : CSUFresno : MatchTalk*/

#include <festival/festival.h>

extern "C" {

 

int fest_init() {

//Default scheme heap size

                  int heap_size = 210000; 

//We want the festival init

// files loaded

int load_init_files = 1;  festival_initialize

  (load_init_files,heap_size);

}

int fest_say(char *s) {

              festival_say_text(s);

}

 

}

 

We need to call fest_init() only once to initialize festival configuration for speech synthesis. From then on, every call to fest_say() will render voice output to the text sent in.

 

When Matchtalk (modified Matchbox for visually impaired) boots up, it starts with a welcome speech. Remember that, we do not have any monitor, hence all the input is provided using keyboard and the output is speech only. The arrow keys on the keyboard are used to navigate the menu. The <Alt>+<Tab> keys are used to toggle between two clients (application windows).

 

To implement the speech for the events happening on the system, we need to provide fest_say() function calls for keyboard handling functions (mainly in wm.h for testing).

 

Client are identified by the name defined in the window manager and whenever they get focus fest_say()  call is used in wm_activate_client() to notify the user of the application receiving focus.

 

Makefile was created to compile the above festival functions into MatchTalk. The relevant contents of the Makefile are as follows:

 

FEST_LIBS = -lFestival -lestools -lestbase -leststring -ltermcap

 

matchbox_LDADD =  -L/usr/X11R6/lib -lX11 -lXext $(XFT_LIBS) $(PNG_LIBS) $(XSET_LIBS) $(EXPAT_LIBS) $(SN_LIBS) $(standalone_libs) $(FEST_LIBS)

 

matchbox_SOURCES = main.c structs.h

wm.c wm.h 

base_client.c base_client.h 

main_client.c main_client.h

toolbar_client.c toolbar_client.h              

dockbar_client.c dockbar_client.h  

dialog_client.c dialog_client.h              

select_client.c select_client.h              

desktop_client.c desktop_client.h  

ewmh.c ewmh.h     

misc.c misc.h              

client_common.c client_common.h

keys.c keys.h   

list.c list.h  

fest.cc $(standalone_src)

 

matchbox_OBJECTS =  main.$(OBJEXT) wm.$(OBJEXT) fest.$(OBJEXT) \

base_client.$(OBJEXT) main_client.$(OBJEXT) \

toolbar_client.$(OBJEXT) \

dockbar_client.$(OBJEXT) dialog_client.$(OBJEXT) \

select_client.$(OBJEXT) desktop_client.$(OBJEXT) \

ewmh.$(OBJEXT) misc.$(OBJEXT) \

client_common.$(OBJEXT) keys.$(OBJEXT) \

list.$(OBJEXT) mbtheme.$(OBJEXT) xml.$(OBJEXT)

#matchbox_OBJECTS =  main.$(OBJEXT) wm.$(OBJEXT) \

main_client.$(OBJEXT) \

dockbar_client.$(OBJEXT) \

select_client.$(OBJEXT) \

ewmh.$(OBJEXT) \

 

fest.o: fest.cc

              g++ -c fest.cc

 

To install the system run at the shell prompt the configure script ($./configure), make the source ($make) and ($make install) install the MatchTalk.

 

MatchTalk can be modified to voice enable most applications that can be supported by the MatchBox or XWindows Window Manager. The more applications you make voice enabled, the more technology you provide to the visually impaired.

 

4. Testing

The system was tested for editor and a few other applications. The users were students (including those who are visually impaired) at the university from different majors.  The visually impaired students needed to be provided with training to use the system.

The system was marked as 4 on a scale of 1 through 5. In terms of usability, the system was marked 3 on a scale of 1 through 5.

One phase of the development is working on supporting the applications requested by the students. Another phase of the development is providing the system with voice recognition so as to reduce the training effort and provide more benefits to the visually impaired.

 

5. Future Work

The advancement of this developed system may lead to providing voice-enabled applications for future Operating Systems. What merely seems like an aid for Visually Impaired can be used as talking computers as in science fictions and is portable to handhelds for providing voice output. When festival comes up with stable version of Voice Recognition System; this can provide a new version of MatchTalk System, making keyboard, mouse and monitor redundant, thereby providing least cost systems. This will significantly reduce the resource requirements of the handhelds and computers.

 

Future scope of the project includes:

·       Voice recognition and voice output computers (Talking Computers),

·       Teachers/Teaching aids,

·       News/Notes/Book readers

 

In addition, MatchTalk system will provide voice authentication systems for the security industry. It can also be used to provide voice commands to the remote systems, thereby raising preconfigured events.

 

MatchTalk, if blended with Artificial Intelligence, can benefit teachers by providing preformatted lectures and answering/explaining a set of questions. Our system then can provide answers based on the reactions. Future extensions to the developed system and the scope of its use are versatile and immense.

 

The system will bring is intended to provide equal opportunity for people with disabilities to learn modern computers and applications.

 

Acknowledgements

This work was partially funded with the grant from Edwards Air Force Base. The authors are thankful to their support.

 

References

[1]  XWindows CVS and Documentation: http://www.xfree.org/

[2]  Festival & Speech synthesis CVS and Documentation: http://www.speech.cs.cmu.edu/festival/ 

[3]  MatchBox CVS and Documentation: http://matchbox.handhelds.org/

[4]  The Speakup Project:

http://www.linux-speakup.org/

[5]              File Specification for the Digital Talking Book ANSI/NSO:

              http://www.linux-speakup.org/niso-dtb.html

[6]              Department Of Justice Section 508:

              http://www.section508.gov/

[7]              W3C Auxiliary Benefits of Accessible Web Design & Policies:

              http://www.w3.org/WAI/Policy/

[8]              Accessibility at IBM:

              http://www-306.ibm.com/able/access_ibm/index.html

[9]              Linux Accessibility Solutions:

http://www.linorg.cirp.usp.br/RedHat8.0/README-Accessibility

 


TXP

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

tareka@csufresno.edu,

+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.