Abstract
In this paper, pair programming is empirically investigated from the perspective of developer personalities and temperaments and how they affect pair effectiveness. A controlled experiment was conducted to investigate the impact of developer personalities and temperaments on communication, pair performance and pair viability-collaboration. The experiment involved 70 undergraduate students and the objective was to compare pairs of heterogeneous developer personalities and temperaments with pairs of homogeneous personalities and temperaments, in terms of pair effectiveness. Pair effectiveness is expressed in terms of pair performance, measured by communication, velocity, design correctness and passed acceptance tests, and pair collaboration-viability measured by developers’ satisfaction, knowledge acquisition and participation. The results have shown that there is important difference between the two groups, indicating better communication, pair performance and pair collaboration-viability for the pairs with heterogeneous personalities and temperaments. In order to provide an objective assessment of the differences between the two groups of pairs, a number of statistical tests and stepwise Discriminant Analysis were used.
Similar content being viewed by others
Notes
This work is funded by the Greek Ministry of Education (25%) and European Union (75%) under the EPEAK II program “Archimedes II”.
Myers–Briggs type indicator and MBTI are registered trademarks of the Myers–Briggs Type Indicator Trust.
References
Ahmad K, Hammond N (2004) Taxonomy of analysis levels of learning effectiveness in collaborative concept mapping. Proceedings of the First International Conference on Concept Mapping, Pamplona, Spain
Arisholm E, Gallis H, Dyba T, Sjøberg D (2007) Evaluating pair programming with respect to system complexity and programmer expertise. IEEE Trans Softw Eng 33(2):65–86 doi:10.1109/TSE.2007.17
Basili V, Rombach H (1988) The TAME project: towards improvement-oriented software environments. IEEE Trans Softw Eng XIV(6):758–773 doi:10.1109/32.6156
Basili V, Weiss D (1984) A methodology for collecting valid software engineering data. IEEE Trans Softw Eng SE-10:728–738
Basili V, Shull F, Lanubille F (1999) Building knowledge through families of experiments. IEEE Trans Softw Eng 25(4):456–473 doi:10.1109/32.799939
Beck K (2000) Extreme programming explained: embrace change. Addison-Wesley, Boston, USA
Berens LV (1998) Understanding yourself and others: an introduction to temperament. Telos, Huntington Beach, CA
Bradley JH, Hebert FJ (1997) The effect of personality type on team performance. J Manage Dev 16(5):337–353 doi:10.1108/02621719710174525
Briand L, Bunse C, Daly J, Differding C (1997) An experimental comparison of the maintainability of object-oriented and structured design documents. Empir Softw Eng 2(3):291–312 doi:10.1023/A:1009720117601
Briand L, Arisholm E, Counsell F, Houdek F, Thevenod-Fosse P (1999) Empirical studies of object-oriented artifacts, methods, and processes: state of the art and future directions. Empir Softw Eng 4(4):387–404 (18)
Campbell DT, Stanley JC (1996) Experimental and quasi-experimental designs for research. Rand McNally, Chicago, pp 1–12, 34–71
Canfora G, Cimitile A, Visaggio CA (2004) Working in pairs as a means for design knowledge building: an empirical study. 12th IEEE International Workshop on Program Comprehension, pp 62–68. ISBN: 0-7695-2149-5
Captez LF (2003) Personality types in software engineering. Int J Hum Comput Stud 58(2):207–214 doi:10.1016/S1071-5819(02)00137-4
Center for Applications of Psychological Type (2006) MBTI Code of Ethics. http://www.capt.org/The_MBTI_Instrument/Ethical_Use.cfm. Last visited: 26 January 2006
Chao J, Atli G (2006) Critical personality traits in successful pair programming. Proceedings of AGILE 2006 Conference (AGILE’06), pp 89–93
Chong J, Hurlbutt T (2007) The social dynamics of pair programming. 29th International Conference on Software Engineering (ICSE'07), pp 354–363
Cockburn A (1998, May/June) The coffee machine design problem: part 1 & 2. C/C++ user’s journal
Cockburn A (2002) Agile software development. Addison-Wesley, Boston, USA
Cockburn A, Williams L (2000) The costs and benefits of pair programming. 1st International Conference on Extreme Programming and Flexible Processes in Software Engineering, Italy (XP2000)
Coleman JS (1990) The foundations of social theory. Harvard University Press, Cambridge, MA
Cook TD, Campbell DT (1979) Quasi-experimentation: design and analysis for field settings. Rand McNally, Chicago, IL, USA
Curtis B, Krasner H, Iscoe N (1988) A field study of the software design process for large systems. Commun ACM 31:1268–1287 doi:10.1145/50087.50089
Dutoit A, Bruegge B (1998) Communication metrics for software development. IEEE Trans Softw Eng 24(8):615–628
Fenton N (1991) Software metrics, a rigorous approach. Chapman & Hall, London
Ferdinandi P (1998) Facilitating communication. IEEE Softw 15(5):92–96 doi:10.1109/52.714835
Forsyth DR (2006) Group dynamics, 4th edn. Belmont, CA, USA
Gallis H, Arisholm E, Dybå T (2002) A transition from partner programming to pair programming–an industrial case study. Pair Programming Work Shop in 17th Annual ACM Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA’02), pp 1–8
Gallis H, Arisholm E, Dybå T (2003) An initial framework for research on pair programming. Proceedings of the 2003 International Symposium on Empirical Software Engineering (ISESE’03), p 132
Gorla N, Lam YW (2004) Who should work with whom? Building effective software project teams. Commun ACM 47(6):79–82 doi:10.1145/990680.990684
Halfhill TR, Sundstrom E, Lahner J, Calderone W, Nielsen TM (2005) Group personality composition and group effectiveness: an integrative review of empirical research. Small Group Res 36(1):83–105 doi:10.1177/1046496404268538
Highsmith J (2002) Agile software development ecosystems. Addison-Wesley, Boston, MA, USA
Hulkko H, Abrahamsson P (2005, May) A multiple case study on the impact of pair programming on product quality. ICSE05. St. Louis, Missouri, USA, pp 495–504
Humphrey WS (1996) Using a defined and measured personal software process. IEEE Softw 13:77–88 doi:10.1109/52.493023
Humphrey WS (1997) Managing technical people: innovation, teamwork, and the software process. Addison Wesley, Reading, MA
Jensen RW (2003) A pair programming experience. CrossTalk. J Def Softw Eng 16:22–24
Johnson PM, Kou H, Agustin JM, Chan C, Moore CA, Miglani J et al (2003) Beyond the personal software process: metrics collection and analysis for the differently disciplined. International Conference on Software Engineering. Portland, Oregon. Proc 2003, pp 641–646
Judd CM, Smith ER, Kidder LH (1991) Research methods in social relations, 6th edn. Holt, Rinehart and Winston, Inc., Toronto
Katira N, Williams L, Wiebe E, Miller C, Balik S, Gehringer E (2004) On understanding compatibility of student pair programmers. ACM Technical Symposium on Computer Science Education, SIGCSE04, pp 7–11
Katira N, Williams L, Osborne J (2005) Towards increasing the compatibility of student pair programmers. International Conference on Software Engineering-ICSE05. St. Louis, Missouri, USA, pp 625–626
Keefer G (2005) Pair programming: an alternative to reviews and inspections? Cutter IT Journal, AVOCA
Keirsey D (1998) Please understand me II. Prometheus Nemesis Book Company, Del Mar, CA
Keirsey D, Bates M (1984) Please understand me.. Prometheus Nemesis Books, Del Mar, California
Khamesan A, Hammond N (2004) Synchronous collaborative concept mapping via ICT: learning effectiveness and personal and interpersonal awareness. Proceeding of 1st International Conference on Concept Mapping (1st CMC, 2004), Spain
Kirkman BL, Tesluk PE, Rosen B (2001) Assessing the incremental validity of team consensus ratings over aggregation of individual-level data in predicting team effectiveness. Person Psychol 54:645–667 doi:10.1111/j.1744-6570.2001.tb00226.x
Kitchenham B, Pfleeger S, Pickard L, Jones P, Hoaglin D, El Emam K et al (2002) Preliminary guidelines for empirical research in software engineering. IEEE Trans Softw Eng 28(8):721–734 doi:10.1109/TSE.2002.1027796
Langley A (1999) Strategies for theorizing from process data. Acad Manage Rev 24(4):691–711 doi:10.2307/259349
Laplante P, Neil C (2006) Antipatterns. Identification, refactoring, and management. Auerbach, USA
Leana CR, Van Buren HJ (1999) rganizational social capital and employment practices. Acad Manage Rev 24(3):538 doi:10.2307/259141
Lui KM, Chan KCC (2003) When does a pair outperform two individuals? Fourth international conference in Extreme Programming and Agile Processes in Software Engineering (XP2003). LNCS 2003. Springer, pp 225–233
Lui KM, Chan KCC (2006) Pair programming productivity: novice–novice vs. expert–expert. Int J Human-Comput Stud 64(9):915–925
Macias F (2004) Empirical assessment of extreme programming. PhD thesis, University of Sheffield (August)
McDonald S, Edwards H (2007) Who should test whom. CACM 50(1):66–71
McDowell C, Werner L, Bullock H, Fernald J (2002) The effect of pair programming on performance in an introductory programming course. ACM Special Interest Group of Computer Science Educators, Covington, KY, pp 38–42
Melnik G, Maurer F (2002) Perceptions of Agile practices: a student survey. XP/Agile Universe, Chicago, IL, pp 241–250
Melnik G, Maurer F (June 2004) Direct verbal communication as a catalyst of Agile knowledge sharing. Proceedings of the Agile Development Conference. IEEE Computer Society, pp 21–31
Müller M (2003) Are reviews an alternative to pair programming? 7th International Conference on Empirical Assessment in Software Engineering, UK, volume 9(4), pp 335–351
Müller M (2005) Two controlled experiments concerning the comparison of pair programming to peer review. J Syst Softw 78(2):166–179 doi:10.1016/j.jss.2004.12.019
Müller M, Tichy W (2001) Case study: extreme programming in a university environment, International Conference on Software Engineering (ICSE), pp 537–544
Myers I (1962) Manual: the Myers–Briggs type indicator. Consulting Psychologists Press, Palo Alto, California
Nawrocki J, Wojciechowski A (2001, April) Experimental evaluation of pair programming. 12th European Software Control and Metrics Conference (ESCOM 2001), London, UK
Nielsen TM, Sundstrom E, Halfhill TR (2005) Group dynamics and effectiveness: five years of applied research. In: Wheelan SA (ed) The handbook of group research and practice. Sage, Thousand Oaks, CA, pp 285–311
Nosek J (1998) The case for collaborative programming. Commun ACM 41(3):105–108 doi:10.1145/272287.272333
Ohira M, Yokomori R, Sakai M, Matsumoto K, Inoue K, Torii K (2004) Empirical project monitor: a tool for mining multiple project data. 1st International Workshop on Mining Software Repositories, Tokyo, Japan, pp 141–150
Saeki M (1995) Communication, collaboration, and cooperation in software development—how should we support group work in software development? Asia-Pacific Software Engineering Conference. Brisbane, Australia, pp 12–20
Seaman C, Basili V (1997) An empirical study of communication in code inspections. 19th International Conference on Software Engineering, Boston, pp 96–106 (May)
Sfetsos P, Angelis L, Stamelos I (2006) Investigating the extreme programming system—an empirical study. Empir Softw Eng 11(2):269–301
Sillitti A, Janes A, Succi G, Vernazza T (2003) Collecting, integrating and analyzing software metrics and personal software process data. Proc EUROMICRO 2003:336–342
Stevens T (1998) The effects of roles and personality characteristics on software development team effectiveness. Dissertation for Doctor of Philosophy, Virginia Polytechnic Institute and State University
Stoyanova N, Kommers P (2002) Concept mapping as a medium of shared cognition in computer supported collaborative problem solving. J Interact Learn Res 13(1/2):111–133
Sundstrom E, De Meuse K, Futrell D (1990) Work teams. Am Psychol 45:120–133 doi:10.1037/0003-066X.45.2.120
Thomas L, Ratcliffe M, Robertson A (2003, February) Code warriors and code-a-phobes: a study in attitude and pair programming, Proceedings of the 34th SIGCSE technical symposium on Computer science education, Reno, Navada, USA, pp 363–367
Tomayko JE (2002) A comparison of pair programming to inspections for software defect reduction. J Comput Sci Educ 12:213–222 doi:10.1076/csed.12.3.213.8614
Trochim W (1999) The research methods knowledge base, 2nd edn. Cornell Custom Publication, Cornell University, Ithaca, NY
Williams L (2001) Integrating pair programming into a software development process. 14th Conference on Software Engineering Education and Training, USA, vol 2001, pp 27–36
Williams L, Kessler R (2003) Pair programming illuminated. Addison-Wesley, USA, Boston
Williams L, Kessler R, Cunningham W, Jeffries R (2000) Strengthening the case for pair-programming. IEEE Softw 17:19–25 doi:10.1109/52.854064
Williams L, Shukla A, Antón AI (2004) An initial exploration of the relationship between pair programming and Brooks’ law. Agile Development Conference, Salt Lake City, Utah, USA, volume issue, 22–26 June 2004, pp 11–20
Williams L, Layman L, Osborne J, Katira N (2006) Examining the compatibility of student pair programmers. Proceedings of Agile 2006-AGILE06, pp 411–420
Wohlin C, Runeson P, Höst M, Ohlson M, Regnell B, Wesslén A (2000) Experimentation in software engineering: an introduction. Kluwer, USA
Acknowledgment
We would like to express our heartfelt gratitude to psychologist Dr. Anastasia Psalti, of the Department of Medicine and Health Care, at the Alexander Technological Educational Institution, Thessaloniki, Greece, for the help she provided in all phases of the experiment and the pilot run of the experiment procedure. We would like to thank the students for their participation in the experiment and both Departments of Informatics of the Alexander Technological Educational Institution and of the Aristotle University, for contribution and support in the completion of the experiment.
Author information
Authors and Affiliations
Corresponding author
Additional information
Editor: Laurie Williams
Appendices
Appendix 1
Communication Transactions Form
Α/Α | Dev. code No. | Requirements (add/delete /modify) | Specification/Design (add/delete /modify) | Coding (add/delete /modify) | Unit testing (add /delete/modify) | Review code/design | Other (describe) |
1 | |||||||
2 | |||||||
3 | |||||||
4 | |||||||
5 | |||||||
6 | |||||||
7 | |||||||
8 | |||||||
9 | |||||||
10 | |||||||
11 | |||||||
12 | : | : | : | : | : |
Write developer code number and tick the appropriate communication mode
Appendix 2
Questionnaire (for pair collaboration-viability)
Appendix 3
The following descriptions refer to the Keirsey type, each type contribution to the population, and descriptive list of identifying characteristics. These descriptions have been extracted from Keirsey and Bates (1984).
3.1 Personalities
Extroverting (E)–Introverting (I)
Extroverts get their energy from the outside world, from experiences and interactions, while Introverts from within themselves, from their internal thoughts, feelings, and reflections. Extroverts tend to talk easily about anything, whereas Introverts are comfortable with long silences. Introverts prefer finished ideas, namely to read and think about something before start talking, so we must give them time to process new information, especially in meetings. For interactions with users and management, Extroverts are better in talking (and getting responses), and at presenting ideas than Introverts.
Sensing (S)–Intuiting (N)
Sensors gather information linearly and tend to take things literally and sequentially, preferring tangible results clearly described. They are observant of what is happening around them, and are especially good at recognizing the practical realities of a situation. Their concentration to details makes them the most capable programmers. Intuitives like to gather information more abstractly (seeing the big picture), focusing on the relationships and connections between facts. They prefer to speak in concepts and global futuristic ideas and they are good at seeing new possibilities and different ways of doing things. Therefore, they can be used more as system analysts determining users/clients' needs and identifying problems in systems.
Thinking (T)–Feeling (F)
Thinkers make decisions based on objective information, while feelers are based on subjective information. Thinkers, tend to be logical, critical, orderly, and prefer to work with facts. They examine carefully cause and effect of a choice or action to enhance their problem-solving abilities. Their tendency to be logical is needed mostly in programming. Feelers, driven by personal values, make decisions considering what is important to themselves and others. Their strengths include understanding, appreciation and support of others. They tend to be more people-oriented and good team-builders.
Judging (J)–Perceiving (P)
The most problems concerning communication are caused by differences in the work styles. Judgers tend to live in an orderly and planned way, with detailed schedules. They like things decided and concluded and they prefer a bad decision than no decision. Perceivers tend to live in a flexible, spontaneous way, are based on experience and have open issues. They like to explore every possibility, and consequently have difficulty making decisions working on deadlines. On the contrary Judgers prefer to avoid last-minute stresses, and try to conclude quickly: once they have found a good solution they accept it and move on to something else. A combination of Judgers and Perceivers in a pair would help to ensure that the best solution will be found in a reasonable time.
3.2 Temperaments
Artisans and guardians prefer concrete communications, while idealist and rational prefer more abstract communications. Artisan and rational types prefer a cooperative path to goal accomplishment, while guardian and idealist types prefer more a utilitarian approach. Artisans, combining a sensor’s sense of reality and a perceiver’s spontaneity, feel most comfortable with clear and direct communications in cooperative pursuit of a goal. Possessing a correct sense of timing, they are great start-up persons, are lateral thinkers, problem solvers and great brainstormers. They are troubleshooters proposing practical solutions and making quick decisions. Their adaptability and sense of innovation can help the pair achieve requirements with new technology.
Guardians, combining a sensor’s sense of reality and a judger’s desire for reaching a conclusion, are traditionalists and stabilizers. They are good as administrators, establishing policies, rules, schedules, regulations and a functioning hierarchy. However, they do not easily perceive project delays or problems. Because of a strong need for conclusions, they may not allow enough time for processing. They tend to want things to remain the same, without allowing for sparks of creativity or innovation. They will not be very successful in times of rapid change.
Combining an intuitive’s focus on the relationships and a feeler’s preference in personal values, Idealists are successful in leveraging their own and other people skills. They like to guide others and are committed to the progress of the people in a given setting. They are also transactional as Artisans, excellent communicators and people motivators. An Idealist developer adds a personalised touch to a pair, contributing to team spirit and morale. However, he does not react well to sudden changes.
Rationalists, combining the objectivity of the thinkers and the visionary of the intuitives, are described as theorists, innovators, systems planners and architects of change. They focus on competence and excellence, valuing high logic and reason, adopting a logical and strategic analysis approach of resolving issues. Thus their most practiced and successful operations tend to be planning, inventing and configuring.
Appendix 4
Samples of checklists and the associated grading schemes.
4.1 Coffee Machine
The coffee machine serves coffee for 35 cents, with or without sugar and creamer. The coffee list includes: black (without sugar and cream powder), white (with cream powder), sweet (with sugar), sweet_white (with sugar and cream powder). The front panel will have four buttons (choice menu with the four types of coffee). There will also be a coin return button. The machine will take euro coins only (max 1 Euro), and give changes. This design consists of 12 classes:
Classes | Responsibility-driven design (RD) |
CoffeeMachine | Initiates the machine; knows how the machine is put together; handles input |
CashBox | (to be implemented) |
FrontPanel | Knows selection; coordinates payment; delegates drink making to the product. |
Product | Knows its recipe and price. |
ProductRegister | Knows what products are available. |
Recipe | Knows the ingredients of a given product; tells dispensers to dispense ingredients in sequence. |
Dispensers | Knows which ingredient it contains; controls dispensing; tracks amount it has left. |
DispenserRegister | Knows what dispensers are available |
Ingredient | Knows its name only. |
Output | Knows how to display text to the user. |
Input | Knows how to receive command-line input from the user |
Main | Initializes the program |
4.2 First Assignment—Cash Administration
Please make the following changes: | Sub Tasks | Points |
Start the machine, inputting a cash amount (i.e. 10,000 cents). | Design | 0.5 |
Code-unit-tests | 1.0 | |
Make customer transactions: | Design | 0.5 |
Give change, checking the amount. | Code-Unit-tests | 0.5 |
Display the proper message if the amount is not enough, and | ->>- | 0.5 |
Input new amount. | ->>- | 0.5 |
End of function: | Design | 0.5 |
Print the total amount of transactions and | Code-unit-tests | 0.5 |
The cash balance. | ->>- | 0.5 |
4.3 Second Assignment—Transactions’ Statistics
Please make the following changes: | Sub Tasks | Points |
Make customer transactions: | Design | 0.5 |
Log each sale transaction. | Code-unit-tests | 0.5 |
End of function: | Design | 0.5 |
1. Sort transactions in descending order. | Code-Unit-tests | 2.0 |
End of function: | Design | 0.5 |
2. Print in a descending order the most sold coffee types. | Code-unit-tests | 1.5 |
The final grade is calculated by summing the points of each sub task.
Personal Software Process and PSP are registered service marks of Carnegie Mellon University.
Rights and permissions
About this article
Cite this article
Sfetsos, P., Stamelos, I., Angelis, L. et al. An experimental investigation of personality types impact on pair effectiveness in pair programming. Empir Software Eng 14, 187–226 (2009). https://doi.org/10.1007/s10664-008-9093-5
Published:
Issue Date:
DOI: https://doi.org/10.1007/s10664-008-9093-5