T. Abdel-Hamid, K. Sengupta, and D. Ronan (1993). Software Project Control: An Experimental Investigation of Judgment with Fallible Information. IEEE Transactions on Software Engineering, 19(6):603–612.

M. Aberdour (2007). Achieving Quality in Open Source Software. IEEE Software, 24(1):58–64.

P. Abrahamsson, O. Salo, J. Ronkainen, and J. Warsta (2002). Agile Software Development Methods. Technical report, VTT Publications 478, VTT, Finland.

A. Abran and P. Robillard (1992). Function Points: A Study of Their Measurement Processes and Scale Transformations. Journal of Systems and Software, 25(2):171–184.

A. Abran and P. Robillard (1996). Function Points Analysis: An Empirical Study of Its Measurement Processes. IEEE Transactions on Software Engineering, 22(12):895–910.

F. Achermann, S. Kneubuehl, and O. Nierstrasz (2000). Scripting coordination styles. In PortoA. and RomanG.-C., editors, COORDINATION 2000: Fourth International Conference on Coordination Languages and Models, pages 19–35. Springer Verlag, LNCS 1906.

E. Adams (1984). Optimizing Preventive Service of Software Products. IBM Journal of Research and Development, 28(1):2–14.

P. Ågerfalk, B. Fitzgerald, H. Holmström, B. Lings, B. Lundel, and E. Conchúir (2006). A Framework for Considering Opportunities and Threats in Distributed Software Development. In Proceedings International Workshop on Distributed Software Engineering, pages 47–61. Austrian Computer Society.

M. Agrawal and K. Chari (2007). Software Effort, Quality, and Cycle Time: A Study of CMM Level 5 Projects. IEEE Transactions on Software Engineering, 33(3):145–156.

M. Åkerholm, J. Carlson, J. Fredrikson, H. Hansson, J. Håkansson, A. Möller, P. Pettersson, and M. Tivoli (2007). The SAVE approach to component-based development of vehicular systems. Journal of Systems and Software, 80(5):655–667.

A. Albrecht (1979). Measuring Applications Development Productivity. In Proceedings Application Development Symposium, pages 83–92. SHARE/GUIDE.

A. Albrecht and J. Gaffney (1983). Software Function, Source Lines of Code, and Development Effort Prediction: A Software Science Validation. IEEE Transactions on Software Engineering, 9(6):639–648.

C. Alexander (1979). The Timeless Way of Building. Oxford University Press.

C. Alexander (1999). The Origins of Pattern Theory. IEEE Software, 16(5):71–82.

C. Alexander, S. Ishikawa, and M. Silverstein (1977). A Pattern Language. Oxford University Press.

T. Allen (1977). Managing the Flow of Technology: Technology Transfer and the Dissemination of Technological Information within the R&D Organization. MIT Press.

V. Ambriola, R. Conradi, and A. Fuggetta (1997). Assessing Process-Centered Software Engineering Environments. ACM Transactions on Software Engineering and Methodology, 6(3):283–328.

A. Arisholm and D. Sjøberg (2004). Evaluating the Effect of a Delegated versus Centralized Control Style on the Maintainability of Object-Oriented Software. IEEE Transactions on Software Engineering, 30(8):521–534.

P. Armour (2001). Zeppelins and Jet Planes: A Metaphor for Modern Software Projects. Communications of the ACM, 44(10):13–15.

P. Armour (2002). The Organism and the Mechanism of Projects. Communications of the ACM, 45(5):17–20.

AsprayW., MayadasF., and VardiM., editors (2006). Globalization and Offshoring of Software. ACM.

U. Assman (2003). Invasive Software Composition. Springer Verlag.

C. Atkinson (2000). Socio-Technical and Soft Approaches to Information Requirements Elicitation in the Post-Methodology Era. Requirements Engineering Journal, 5(2):67–73.

R. Austin and L. Devin (2003). Beyond Requirements: Software Making as Art. IEEE Software, 20(1):93–95.

D. Avison, S. Gregor, and D. Wilson (2006). Managerial IT Unconsciousness. Communications of the ACM, 49(7):89–93.

R. Baber (1982). Software Reflected. North-Holland Publishing Company.

W. Babich (1986). Software Configuration Management. Addison-Wesley.

N. Baddoo and T. Hall (2003). De-motivators for software process improvement: an analysis of practitioners' views. Journal of Systems and Software, 66(1):23–34.

F. Baker (1972). Chief Programmer Team Management of Production Programming. IBM Systems Journal, 11(1):56–73.

R. Banker, S. Datar, C. Kemerer, and D. Zweig (1993). Software Complexity and Maintenance Costs. Communications of the ACM, 36(11):81–94.

R. Banker, R. Kauffman, and R. Kumar (1991). An Empirical Test of Object-Based Output Measurement Metrics in a Computer Aided Software Engineering (CASE) Environment. Journal of Management Information Systems, 8(3):127–150.

G. Baram and G. Steinberg (1989). Selection Criteria for Analysis and Design CASE Tools. ACM Software Engineering Notes, 14(6):73–80.

H. Barnard, R. Metz, and A. Price (1986). A Recommended Practice for Describing Software Designs: IEEE Standards Project 1016. IEEE Transactions on Software Engineering, 12(2):258–263.

B. Barnes and T. Bollinger (1991). Making Reuse Cost-Effective. IEEE Software, 8(1):13–24.

BarstowD., ShrobeH., and SandewallE., editors (1984). Interactive Programming Environments. McGraw-Hill.

V. Basili (1990). Viewing Maintenance as Reuse-Oriented Software Development. IEEE Software, 7(1):19–25.

V. Basili, L. Briand, S. Condon, Y.-M. Kim, W. Melo, and J. Valen (1996). Understanding and Predicting the Process of Software Maintenance Releases. In Proceedings International Conference on Software Maintenance (ICSM'96), pages 464–474. IEEE.

V. Basili, F. McGarry, R. Pajersky, and M. Zelkowitz (2002). Lessons Learned from 25 Years of Process Improvement. In Proceedings 24th International Conference on Software Engineering (ICSE24), pages 69–79. IEEE.

V. Basili and R. Selby (1987). Comparing the Effectiveness of Software Testing Strategies. IEEE Transactions on Software Engineering, 13(12):1278–1296.

L. Bass, P. Clements, and R. Kazman (2003). Software Architecture in Practice. Addison-Wesley, second edition.

C. Batini, S. Ceri, and S. Navathe (1992). Conceptual Database Design: An Entity-Relationship Approach. Benjamin Cummings.

K. Beck (2000). Extreme Programming Explained. Addison-Wesley.

K. Beck (2003). Test-Driven Development. Addison-Wesley.

K. Beck and W. Cunningham (1989). A Laboratory For Teaching Object-Oriented Thinking. In OOPSLA '89 Proceedings, ACM SIGPLAN Notices 24(10), pages 1–6.

K. Beck et al. (2001). Manifesto for Agile Software Development. http://agilemanifesto.org.

B. Beizer (1995). Black Box Testing. John Wiley & Sons.

B. Bellay and H. Gall (1998). An Evaluation of Reverse Engineering Tool Capabilities. Journal of Software Maintenance: Research and Practice, 10:305–331.

H. Benington (1983). Production of Large Computer Programs. In Proceedings ONR Symposium (1956), reprinted in Annals of the History of Computing 5(4), pages 350–361.

K. Bennett (1998). Do Program Transformations Help Reverse Engineering? In Proceedings International Conference on Software Maintenance (ICSM'98), pages 247–254. IEEE.

K. Bennett and V. Rajlich (2000). Software Maintenance and Evolution: a Roadmap. In Finkelstein, A., editor, The Future of Software Engineering, pages 73–87. ACM Press.

G. Bergland and R. Gordon (1981). Tutorial: Software Design Strategies. IEEE, EZ389.

T. Berners-Lee, J. Hendler, and O. Lassila (2001). The Semantic Web. Scientific American, 284(5):34–43.

E. Bersoff and A. Davis (1991). Impacts of Life Cycle Models on Software Configuration Management. Communications of the ACM, 34(8):104–118.

H. Beyer and K. Holtzblatt (1995). Apprenticing with the Customer. Communications of the ACM, 38(5):45–52.

BiasG. and MayhewD., editors (1994). Cost-Justifying Usability. Academic Press.

J. Bieman, D. Jain, and H. Yang (2001). OO Design Patterns, Design Structure, and Program Changes: An Industrial Case Study. In Proceedings International Conference on Software Maintenance (ICSM'01), pages 580–589. IEEE.

S. Biffl and M. Halling (2002). Investigating the Influence of Inspector Capability Factors with Four Inspection Techniques on Inspection Performance. In Proceedings 8th IEEE International Software Metrics Symposium, pages 107–17. IEEE.

J. Biggerstaff, B. Mitbander, and D. Webster (1994). Program Understanding and the Concept Assignment Problem. Communications of the ACM, 37(5):72–83.

T. Biggerstaff (1989). Design Recovery for Maintenance and Reuse. IEEE Computer, 22(7):36–50.

BiggerstaffT. and PerlisA., editors (1989). Software Reusability, Volume I: Concepts and Models, Volume II: Applications and Experience. Addison-Wesley.

R. Binder (2000). Testing Object-Oriented Systems. Addison-Wesley.

J. Bisbal, D. Lawless, B. Wu, and J. Grimson (1999). Legacy Information Systems: Issues and Directions. IEEE Software, 16(5):103–111.

B. Blum (1994). A Taxonomy of Software Development Methods. Communications of the ACM, 37(11):82–94.

B. Boehm (1975). Some Experience with Automated Aids to the Design of Large-Scale Reliable Software. In Proceedings International Conference on Reliable Software, ACM SIGPLAN Notices 10(6), pages 105–113. ACM.

B. Boehm (1976). Software Engineering. IEEE Transactions on Computers, C-25(12):1226–1241.

B. Boehm (1981). Software Engineering Economics. Prentice Hall.

B. Boehm (1983). The Economics of Software Maintenance. In Proceedings Software Maintenance Workshop, pages 9–37. IEEE, 83CH1982-8.

B. Boehm (1984a). Software Life Cycle Factors. In VickC. and RamamoorthyC., editors, Handbook of Software Engineering, pages 494–518. Van Nostrand Reinhold.

B. Boehm (1984b). Verifying and Validating Software Requirements and Design Specifications. IEEE Software, 1(1):75–88.

B. Boehm (1987a). Improving Software Productivity. IEEE Computer, 20(9):43–57.

B. Boehm (1987b). Industrial Software Metrics Top 10 List. IEEE Software, 4(5):84–85.

B. Boehm (1988). A Spiral Model of Software Development and Enhancement. IEEE Computer, 21(5):61–72.

B. Boehm (1989). Software Risk Management. IEEE.

B. Boehm, C. Abts, A. Brown, S. Chulani, B. Clark, E. Horowitz, R. Madachy, D. Reifer, and B. Steece (2000). Software Cost Estimation with COCOMO II. Prentice Hall.

B. Boehm and V. Basili (2001). Software Defect Reduction Top 10 List. IEEE Computer, 34(1):135–137.

B. Boehm, J. Brown, H. Kaspar, M. Lipow, G. MacLeod, and M. Merrit (1978). Characteristics of Software Quality. Number 1 in TRW Series of Software Technology. North-Holland.

B. Boehm et al. (1997). COCOMO II Model Definition Manual. Technical report, University of Southern California.

B. Boehm and K. Sullivan (1999). Software economics: status and prospects. Information and Software Technology, 41(14):937–946.

B. Boehm and R. Turner (2003). Balancing Agility and Discipline. Addison-Wesley.

B. Boehm and R. Turner (2005). Management Challenges in Implementing Agile Processes in Traditional Development Organizations. IEEE Software, 22(5):30–39.

C. Böhm and G. Jacopini (1966). Flow Diagrams, Turing Machines, and Languages With Only Two Formation Rules. Communications of the ACM, 9(5):366–371.

K. Bohrer, V. Johnson, A. Nilsson, and B. Rudin (1998). Business Process Components for Distributed Object Applications. Communications of the ACM, 41(6):43–48.

G. Booch (1987). Software Components with Ada: Structures, Tools, and Subsystems. Benjamin Cummings.

G. Booch (1994). Object-Oriented Analysis and Design with Applications. Benjamin Cummings, second edition.

G. Booch, J. Rumbaugh, and I. Jacobson (1999). UML User Guide. Addison-Wesley.

G. Borchers (2003). The Software Engineering Impacts of Cultural Factors on Multi-cultural Software Development Teams. In Proceedings 25th International Conference on Software Engineering (ICSE25), pages 540–545. IEEE.

G. Bounds, L. Yorks, M. Adams, and G. Ranney (1994). Beyond Total Quality Management. McGraw-Hill.

D. Box (1997). Essential COM. Addison-Wesley, Object Technology Series.

G. Bracha and W. Cook (1990). Mixin-Based Inheritance. In Meyrowitz, N., editor, Proceedings of the Conference on Object-Oriented Programming: Systems, Languages, and Applications / Proceedings of the European Conference on Object-Oriented Programming, pages 303–311. ACM Press.

F. Brooks, Jr. (1987). No Silver Bullet: Essence and Accidents of Software Engineering. IEEE Computer, 20(4):10–20.

F. Brooks, Jr. (1995). The Mythical Man-Month. Addison-Wesley, second edition.

R. Brooks (1983). Towards a Theory of the Comprehension of Computer Programs. International Journal of Man-Machine Studies, 18:543–554.

W. Brown, H. M. Malveau R., III, and T. Mowbray (1998). AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis. John Wiley & Sons.

E. Browning (1994). Side by side: Computer chip project brings rivals together, but the cultures clash; Foreign work habits get in the way of creative leaps, hobbling joint research. Softball is not the answer. Wall Street Journal, May 3:page A1.

D. Budgen (2003). Software Design. Addison-Wesley, second edition.

E. Burch and H.-J. Kung (1997). Modeling Software Maintenance Requests: A Case Study. In Proceedings International Conference on Software Maintenance (ICSM'97), pages 40–47.

B. Burke and R. Monson-Haefel (2006). Enterprise JavaBeans 3.0. O'Reilly, fifth edition.

F. Buschmann, R. Meunier, H. Rohnert, P. Sommerlad, and M. Stal (1996). A System of Patterns. John Wiley & Sons.

E. Bush (1985). The Automatic Restructuring of COBOL. In Proceedings Conference on Software Maintenance, pages 35–41. IEEE.

BuxtonJ. and RandellB., editors (1969). Software Engineering Techniques, Report on a Conference. NATO Scientific Affairs Division, Rome.

CACM (1993a). Special Issue on Participatory Design. Communications of the ACM, 36(6).

CACM (1993b). Special Issue on Project Organization and Management. Communications of the ACM, 36(10).

CACM (1997). Special Issue: The Quality Approach: Is It Delivering. Communications of the ACM, 40(6).

CACM (2003). Special Issue: Service-Oriented Computing. Communications of the ACM, 46(10).

CACM (2006). Special Issue: Services Science. Communications of the ACM, 49(7).

J. Cameron (1989). JSP & JSD, The Jackson Approach to Software Development. IEEE.

M. Campbell-Kelly (2003). From Airline Reservations to Sonic the Hedgehog. MIT Press.

S. Card, T. Moran, and A. Newell (1983). The Psychology of Human—Computer Interaction. Erlbaum.

E. Carmel (1999). Global Software Teams. Prentice Hall.

E. Carmel, R. Whitaker, and J. George (1993). PD and Joint Application Design: A Transatlantic Comparison. Communications of the ACM, 36(6):40–48.

E. Carroll (2005). Estimating Software Based on Use Case Points. In Conference on Object Oriented Programming, Systems, Languages and Applications (OOPSLA), pages 257–265. ACM.

J. Carroll (1990). The Nurnberg Funnell: Designing Minimalist Instruction for Practical Computer Skill. MIT Press.

J. Carroll (1995). Scenario-Based Design. John Wiley & Sons.

V. Casey and I. Richardson (2006). Uncovering the Reality Within Virtual Software Teams. In Proceedings International Conference on Global Software Engineering (ICGSE'06). IEEE.

S. Cha, N. Leveson, and T. Shimeall (1988). Safety Verification in MURPHY using Fault-Tree Analysis. In Proceedings 10th International Conference on Software Engineering (ICSE10), pages 377–386. IEEE.

N. Chapin (1987). The Job of Software Maintenance. In Proceedings Conference on Software Maintenance, pages 4–12. IEEE.

N. Chapin, J. Hale, K. Khan, J. Ramil, and W.-G. Tan (2001). Types of software evolution and software maintenance. Journal of Software Maintenance and Evolution: Research and Practice, 13:3–30.

D. Chappell (2006). Understanding.NET. Addison-Wesley.

J. Cheesman and J. Daniels (2000). UML Components. Addison-Wesley.

P. Chen (1976). The Entity-Relationship Model: Toward a Unifying View of Data. ACM Transactions on Data Base Systems, 1(1):9–36.

S. Chidamber and C. Kemerer (1994). A Metrics Suite for Object Oriented Design. IEEE Transactions on Software Engineering, 20(6):476–493.

E. Chikofsky (1990). CASE & Reengineering: From Archeology to Software Perestroika. In Proceedings 12th International Conference on Software Engineering (ICSE12), page 122. IEEE.

E. Chikofsky and J. Cross II (1990). Reverse Engineering and Design Recovery: A Taxonomy. IEEE Software, 7(1):13–18.

N. Churcher and M. Shepperd (1995). Comments on 'A Metrics Suite for Object Oriented Design'. IEEE Transactions on Software Engineering, 21(3):263–265.

M. Ciolkowski, O. Laitenberger, and S. Biffl (2003). Software Reviews: The State of the Practice. IEEE Software, 20(6):46–51.

L. Clarke, A. Podgurski, D. Richardson, and S. Zeil (1989). A Formal Evaluation of Data Flow Path Selection Criteria. IEEE Transactions on Software Engineering, 15(11):1318–1332.

P. Clements, F. Bachman, L. Bass, D. Garlan, J. Ivers, R. Little, R. Nord, and J. Stafford (2003). Documenting Software Architectures: Views and Beyond. Addison-Wesley.

P. Clements, R. Kazman, and M. Klein (2002). Evaluating Software Architectures: Methods and Case Studies. Addison-Wesley.

P. Clements and L. Northrop (2002). Software Product Lines: Practices and Patterns. Addison-Wesley.

R. Clemmons (2006). Project Estimation With Use Case Point. Crosstalk, 14(3).

V. Clerc, P. Lago, and H. v. Vliet (2007). Global Software Development: Are Architectural Rules the Answer? In Proceedings International Conference on Global Software Engineering (ICGSE'07). IEEE.

CMMI Product Team (2006). CMMI for Development. Technical report, CMU/SEI-2006-TR-008, Software Engineering Institute.

P. Coad and E. Yourdon (1991). Object-Oriented Analysis. Yourdon Press, second edition.

J. Coakes and E. Coakes (2000). Specifications in Context: Stakeholders, Systems and Modelling of Conflict. Requirements Engineering Journal, 5(2):103–113.

A. Cockburn (1996). The Interaction of Social Issues and Software Architecture. Communications of the ACM, 39(10):40–46.

A. Cockburn (2001). Writing Effective Use Cases. Addison-Wesley.

A. Cockburn (2002). Agile Software Development. Addison-Wesley.

M. Cohn (2006). Agile Estimation and Planning. Prentice Hall.

D. Coleman (1996). Fusion with Use Cases: Extending Fusion for Requirements Modelling. Technical report, available through URL http://www.hpl.hp.com/fusion/index.html.

D. Coleman, P. Arnold, S. Bodoff, C. Dollin, H. Gilchrist, F. Hayes, and P. Jeremaes (1994). Object-Oriented Development: The FUSION Method. Prentice Hall.

J. Collofello and S. Woodfield (1989). Evaluating the Effectiveness of Reliability-Assurance Techniques. Journal of Systems and Software, 9(3):191–195.

B. Colwell (2002). Near Misses: Murphy's Law is Wrong. IEEE Computer, 35(4):9–12.

E. Conchúir, H. Holmström, P. Ågerfalk, and B. Fitzgerald (2006). Exploring the Assumed Benefits of Global Software Development. In Proceedings International Conference on Global Software Engineering (ICGSE'06). IEEE.

J. Conklin (1987). Hypertext: An Introduction and Survey. IEEE Computer, 20(9):17–41.

J. Conklin and M. Begeman (1988). gIBIS: A Hypertext Tool for Exploratory Policy Discussion. ACM Transactions on Office Information Systems, 6(4):303–331.

R. Conradi and A. Fuggetta (2002). Improving Software Process Improvement. IEEE Software, 19(4):92–99.

R. Conradi, A. Fuggetta, and M. Jaccheri (1998). Six Theses on Software Process Research. In Gruhn, V., editor, Software Process Technology, 6th European workshop, EWSPT'98. Springer Verlag, LNCS 1487.

L. Constantine (1993). Work Organization: Paradigms for Project Management and Organization. Communications of the ACM, 36(10):34–43.

S. Conte, H. Dunsmore, and V. Shen (1986). Software Engineering Metrics and Models. Benjamin Cummings.

M. Conway (1968). How Do Committees Invent. Datamation, 14(4):28–31.

S. Cook, R. Harrison, M. Lehman, and P. Wernick (2006). Evolution in software systems: foundations for the SPE classification scheme. Journal of Software Maintenance and Evolution: Research and Practice, 18(1):1–35.

L. Copeland (2003). A Practitioner's Guide to Software Test Design. Artech House Publishers.

T. Corby (1989). Program Understanding: Challenge for the 1990s. IBM Systems Journal, 28(2):294–306.

D. Corkill (1997). Countdown to Success: Dynamic Objects, GBB, and RADARSET-1. Communications of the ACM, 40(5):48–58.

E. Corlett and T. Clark (1995). The Ergonomics of Workspaces and Machines. Taylor & Francis Ltd., London.

G. Costagliola, F. Ferrucci, G. Tortora, and G. Vitiello (2005). Class Point: An Approach for the Size Estimation of Object-Oriented Systems. IEEE Transactions on Software Engineering, 31(1):52–74.

M.-A. Côté, W. Suryn, and E. Georgiadou (2006). Software Quality Model Requirements for Software Quality Engineering. In Proceedings 14th International Software Quality Management & INSPIRE Conference.

J. Couger and R. Zawacki (1980). Motivating and Managing Computer Personnel. Wiley.

B. Cox (1990). Planning the Software Industrial Revolution. IEEE Software, 7(6):25–33.

I. Crnkovic and M. Larsson (2002a). Building Reliable Component-Based Software Systems. Artech House.

I. Crnkovic and M. Larsson (2002b). Challenges of component-based development. Journal of Systems and Software, 61(3):201–212.

K. Crowston and J. Howison (2006). Assessing the Health of Open Source Communities. IEEE Computer, 39(5):89–91.

G. Cugola, E. di Nitto, A. Fuggetta, and C. Ghezzi (1996). A Framework for Formalizing Inconsistencies and Deviations in Human-Centered Systems. ACM Transactions on Software Engineering and Methodology, 5(3):191–230.

G. Cugola and C. Ghezzi (1998). Software Processes: a Retrospective and a Path to the Future. Software Process — Improvement and Practice, 4(3):101–123.

F. Curbera, M. Duftler, R. Khalaf, W. Nagy, N. Mukhi, and S. Weerawarana (2002). Unraveling the Web services Web: An introduction to SOAP, WSDL, and UDDI. IEEE Internet Computing, 6(2).

P. Currit, M. Dyer, and H. Mills (1986). Certifying the Reliability of Software. IEEE Transactions on Software Engineering, 12(1):3–11.

B. Curtis (1989). Three Problems Overcome with Behavioral Models of the Software Development Process. In Proceedings 11th International Conference on Software Engineering (ICSE11), pages 398–399. IEEE.

B. Curtis, H. Krasner, and N. Iscoe (1988). A Field Study of the Software Design Process for Large Systems. Communications of the ACM, 31(11):1268–1287.

B. Curtis, H. Krasner, V. Shen, and N. Iscoe (1987). On Building Software Process Models Under the Lamppost. In Proceedings 9th International Conference on Software Engineering (ICSE9), pages 96–103.

B. Curtis, S. Sheppard, and P. Milliman (1979). Third Time Charm: Stronger Prediction of Programmer Performance by Software Complexity Metrics. In Proceedings 4th International Conference on Software Engineering (ICSE4), pages 356–360. IEEE.

M. Cusumano (1989). The Software Factory: A Historical Interpretation. IEEE Software, 6(2):23–30.

M. Cusumano and D. Yoffe (1999). Software Development on Internet Time. Computer, 32(10):60–69.

D. Damian (2007). Stakeholders in Global Requirements Engineering: Lessons Learned from Practice. IEEE Software, 24(2):21–27.

D. Damian and D. Zowghi (2003). RE challenges in multi-site software development organizations. Requirements Engineering, 8:149–160.

D. Darcy (2005). The Structural Complexity of Software: An Experimental Test. IEEE Transactions on Software Engineering, 31(11):982–995.

D. Darcy and C. Kemerer (2005). OO Metrics in Practice. IEEE Software, 22(6):17–19.

P. Darke and G. Shanks (1996). Stakeholder Viewpoints in Requirements Definition: A Framework for Understanding Viewpoint Development Approaches. Requirements Engineering Journal, 1:88–105.

S. Dart (1990). Spectrum of Functionality in Configuration Management Systems. Technical report, CMU/SEI-90-TR-11, Software Engineering Institute.

S. Dart, R. Ellison, P. Feiller, and A. Habermann (1987). Software Development Environments. IEEE Computer, 20(11):18–28.

T. Davenport (1993). Process Innovation: Reengineering Work through Information Technology. Harvard Business School PressCambridge, MA.

A. Davis (1993). Software Requirements: Objects, Functions and State. Prentice Hall, second edition.

A. Davis (1995). Object-Oriented Requirements to Object-Oriented Design: An Easy Transition? Journal of Systems and Software, 30(1 & 2):151–159.

A. Davis (2005). Just Enough Requirements Management. Dorset House.

G. Davis (1982). Strategies for Information Requirements Determination. IBM Systems Journal, 21(1):4–30.

S. Dekleva (1992). Delphi Study of Software Maintenance Problems. In Proceedings International Conference on Software Maintenance (ICSM'92), pages 10–17. IEEE.

N. Delisle and D. Garlan (1990). Applying Formal Specification to Industrial Problems: A Specification of an Oscilloscope. IEEE Software, 7(5):29–37.

W. DeLone, J. Espinosa, G. Lee, and E. Carmel (2005). Bridging Global Boundaries for IS Project Success. In Proceedings 38th Hawaii International Conference on Information Sciences (HICSS), pages 1–10. IEEE.

T. DeMarco (1979). Structured Analysis and System Specification. Prentice Hall.

T. DeMarco (1982). Controlling Software Projects. Yourdon Press.

T. DeMarco and T. Lister (1989). Software Development: State of the Art vs. State of the Practice. In Proceedings 11th International Conference on Software Engineering (ICSE11), pages 271–275. IEEE.

T. DeMarco and T. Lister (1999). Peopleware: Productive Projects and Teams. Dorset House, second edition.

R. DeMillo, R. Lipton, and A. Perlis (1979). Social Processes and the Proofs of Theorems and Programs. Communications of the ACM, 22(5):271–280.

F. DeRemer and H. Kron (1976). Programming-in-the-large Versus Programming-in-the-small. IEEE Transactions on Software Engineering, 2(2):80–86.

K. Desouza, Y. Awazu, and P. Baloh (2006). Managing Knowledge in Global Software Development Efforts: Issues and Practices. IEEE Software, 23(5):30–37.

A. v. Deursen, C. Hofmeister, R. Koschke, L. Moonen, and C. Riva (2004). Symphony: View-Driven Software Architecture Reconstruction. In Proceedings 4th Working IEEE/IFIP Conference on Software Architecture (WICSA4), pages 122–132. IEEE.

P. Devanbu, R. Brachman, P. Selfridge, and B. Ballard (1991). LASSIE: A Knowledge-Based Software Information System. Communications of the ACM, 34(5):34–49.

M. Diaz and J. Sligo (1997). How Software Process Improvement Helped Motorola. IEEE Software, 14(5):75–81.

A. Dix, J. Finlay, G. Abowd, and R. Beale (1998). Human—Computer Interaction. Prentice Hall.

B. Dobing and J. Parsons (2006). How UML is used. Communications of the ACM, 49(5):109–113.

L. Dobrica and E. Niemelä (2002). A Survey of Software Architecture Analysis Methods. IEEE Transactions on Software Engineering, 28(7):638–653.

T. Dolotta, R. Haight, and J. Mashey (1978). UNIX Time-Sharing System: The Programmer's Workbench. The Bell System Technical Journal, 57(6):2177–2200.

E. Downs, P. Clare, and I. Coe (1992). SSADM: Structured Systems Analysis and Design Method. Prentice Hall, second edition.

S. Ducasse, T. Gîrba, and A. Kuhn (2006). Distribution Map. In Proceedings International Conference on Software Maintenance (ICSM'06), pages 203–212. IEEE.

A. Dunsmore, M. Roper, and M. Wood (2002). Further Investigations into the Development and Evaluation of Reading Techniques for Object-Oriented Code Inspection. In Proceedings 24th International Conference on Software Engineering (ICSE24), pages 47–57. IEEE.

T. Dybå (2005). An Instrument for Measuring the Key Factors of Success in Software Process Improvement. Empirical Software Engineering, 5(4):410–424.

K. Ehrlich and K. Chang (2006). Leveraging expertise in global software teams: Going outside boundaries. In Proceedings International Conference on Global Software Engineering (ICGSE'06). IEEE.

K. Eischen (2002). Software Development: An Outsider's View. IEEE Computer, 35(5):36–44.

K. El Emam, S. Benlarbi, N. Goel, and S. Rai (2001). The Confounding Effect of Class Size on the Validity of Object-Oriented Metrics. IEEE Transactions on Software Engineering, 27(7):630–650.

K. El Emam, J. Drouin, and W. Melo (1997). SPICE: The Theory and Practice of Software Process Improvement and Capability Determination. IEEE.

K. El Emam and N. Madhavji (1995). The Reliability of Measuring Organizational Maturity. Software Process — Improvement and Practice, 1(1):3–25.

J. Elshoff (1976). Measuring Commercial PL-1 Programs Using Halstead's Criteria. ACM SIGPLAN Notices, 11(5):38–76.

W. Emmerich, M. Aoyama, and J. Sventek (2007). The Impact of Research on Middleware Technology. ACM SIGSOFT Software Engineering Notes, 32(1):21–46.

A. Endres and D. Rombach (2003). A Handbook of Software and Systems Engineering. Pearson.

R. Epstein (1997). The Case of the Killer Robot. John Wiley & Sons.

H. Erdogmus, M. Morisio, and M. Torchiano (2005). On the Effectiveness of the Test-First Approach to Programming. IEEE Transactions on Software Engineering, 31(3):226–237.

T. Erl (2005). Service-Oriented Architecture: Concepts, Technology and Design. Prentice Hall.

J. Estublier, D. Leblang, A. van der Hoek, R. Conradi, G. Clemm, W. Tichy, and D. Wiborg-Weber (2005). Impact of Software Engineering Research on the Practice of Software Configuration Management. ACM Transactions on Software Engineering and Methodology, 14(4):383–430.

D. Fafchamps (1994). Organizational Factors and Reuse. IEEE Software, 11(5):31–41.

M. Fagan (1976). Design and Code Inspections to Reduce Errors in Program Development. IBM Systems Journal, 15(3):182–211.

M. Fagan (1986). Advances in Inspections. IEEE Transactions on Software Engineering, 12(7):744–751.

D. Fairley (2002). Making Accurate Estimates. IEEE Software, 19(6):61–63.

R. Fairley and M. Wilshire (2003). Why the Vasa Sank: 10 Problems and Some Antidotes for Software Projects. IEEE Software, 20(2):18–25.

Y. Fang and D. Neufeld (2006). Should I Stay or Should I Go? Worker Commitment to Virtual Organizations. In Proceedings 39th Hawaii International Conference on Information Sciences (HICSS). IEEE.

M. Fayad (1997). Software Development Process: A Necessary Evil. Communications of the ACM, 40(9):101–103.

M. Fayad and M. Laitinen (1997). Process Assessment Considered Wasteful. Communications of the ACM, 40(11):125–128.

S. Feldman (1978). Make: A Program for Maintaining Computer Programs. Technical report, AT&T.

N. Fenton and S. L. Pfleeger (1996). Software Metrics: A Rigorous & Practical Approach. Thomson Computer Press, second edition.

J. H. Fetzer (1988). Program Verification: The Very Idea. Communications of the ACM, 31(9):1048–1063. See also ref: Communications of the ACM 32(3):374–381 (1989) and 32(4):506–512 (1989).

R. Fichman and C. Kemerer (2001). Incentive Compatibility and Systematic Software Reuse. Journal of Systems and Software, 57(1):45–60.

FinkelsteinA., editor (2000). The Future of Software Engineering. ACM Press.

G. Fischer (1986). From Interactive to Intelligent Systems. In Skwirzynski, J., editor, Software System Design Methods, volume 22 of NATO ASI Series F: Computer and Systems Sciences, pages 185–212. Springer Verlag.

M. Fischer and H. Gall (2004). Visualizing feature evolution of large-scale software based on problem and modification report data. Journal of Software Maintenance and Evolution: Research and Practice, pages 385–403.

B. Fitzgerald and T. O'Kane (1999). A Longitudinal Study of Software Process Improvement. IEEE Software, 16(3):37–51.

A. Fitzsimmons and T. Love (1978). A Review and Evaluation of Software Science. ACM Computing Surveys, 10(1):3–18.

R. Fjelstad and W. Hamlen (1979). Application Program Maintenance Study: Report to our Respondents. In Proceedings of GUIDE 48.

S. Flowers (1996). Software Failure: Management Failure. John Wiley & Sons.

C. Floyd, W.-M. Mehl, F.-M. Reisin, G. Schmidt, and G. Wolf (1989). Out of Scandinavia: Alternative Approaches to Software Design and System Development. Human—Computer Interaction, 4:253–350.

E. Folmer, J. van Gurp, and J. Bosch (2003). A Framework for Capturing the Relationship between Usability and Software Architecture. Software Process Improvement and Practice, 8(2):67–87.

M. Fowler (1999). Refactoring: Improving the Design of Existing Code. Addison-Wesley.

M. Fowler (2003). Who Needs an Architect. IEEE Software, 20(5):11–13.

M. Fowler (2004). UML Distilled. Addison-Wesley, third edition.

W. Frakes and P. Gandel (1990). Representing Reusable Software. Information and Software Technology, 32(10):653–664.

W. Frakes and K. Kang (2005). Software Reuse Research: Status and Future. IEEE Transactions on Software Engineering, 31(7):529–536.

W. Frakes and C. Terry (1996). Software Reuse: Metrics and Models. ACM Computing Surveys, 28(5):415–435.

P. Frankl and S. Weiss (1993). An Experimental Comparison of the Effectiveness of Branch Testing and Data Flow Testing. IEEE Transactions on Software Engineering, 19(8):774–787.

P. Frankl, S. Weiss, and C. Hu (1997). All-Uses vs Mutation Testing: An Experimental Comparison of Effectiveness. Journal of Systems and Software, 38(3):235–253.

P. Frankl and E. Weyuker (1993a). A Formal Analysis of the Fault-Detection Ability of Testing Methods. IEEE Transactions on Software Engineering, 19(3):202–213.

P. Frankl and E. Weyuker (1993b). Provable Improvements on Branch Testing. IEEE Transactions on Software Engineering, 19(10):962–975.

FreemanP., editor (1987). Tutorial: Software Reusability. IEEE, EZ750.

FreemanP. and WassermanA., editors (1983). Tutorial: Software Design Techniques. IEEE EZ514.

A. Fuggetta (1993). A Classification of CASE Technology. IEEE Computer, 26(12):25–38.

FuggettaA. and WolfA., editors (1996). Software Process — Improvement and Practice. John Wiley & Sons.

S. Fussell, R. Krut, F. Lerch, W. Scherlis, M. McNally, and J. Cadiz (1998). Coordination, Overload and Team Performance: Effects of Team Communication Strategies. In Proceedings ACM CSCW '98, pages 275–284.

E. Gamma, R. Helm, R. Johnson, and J. Vlissides (1995). Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley.

C. Gane and T. Sarson (1979). Structured Analysis and Systems Analysis: Tools and Techniques. Prentice Hall.

J. Gao, F. Itaru, and Y. Toyoshima (2002). Managing Problems for Global Software Production — Experience and Lessons. Information Technology and Management, 3:85–112.

D. Garlan, R. Allen, and J. Ockerbloom (1995). Architectural Mismatch: Why Reuse Is So Hard. IEEE Software, 12(6):17–26.

D. Garlan, G. Kaiser, and D. Notkin (1992). Using Tool Abstraction to Compose Systems. IEEE Computer, 25(6):30–38.

D. Garmus and D. Herron (1996). Measuring the Software Process: A Practical Guide to Functional Measurements. Prentice Hall.

Gartner (2001). Describing the Capability Maturity Model. Measure IT. Gartner Inc, http:///www.gartner.com/measurements.

D. Garvin (1984). What does 'Product Quality' really mean? Sloan Management Review.

D. Gelperin and B. Hetzel (1988). The Growth of Software Testing. Communications of the ACM, 31(6):687–695.

M. v. Genuchten (1991). Towards a Software Factory. PhD thesis, Technical University of Eindhoven, The Netherlands.

V. Gibson and J. Senn (1989). System Structure and Software Maintenance Performance. Communications of the ACM, 32(3):347–358.

T. Gilb (1988). Principles of Software Engineering Management. Addison-Wesley.

T. Gilb and D. Graham (1993). Software Inspection. Addison-Wesley.

T. Gîrba and S. Ducasse (2006). Modeling history to analyze software evolution. Journal of Software Maintenance and Evolution: Research and Practice, 18:207–236.

T. Gîrba, S. Ducasse, and M. Lanza (2004). Yesterday's Weather: Guiding early reverse engineering efforts by summarizing the evolution of changes. In Proceedings International Conference on Software Maintenance (ICSM'04), pages 40–49. IEEE.

R. Glass (2003). Facts and Fallacies of Software Engineering. Addison-Wesley.

M. Godfrey and Q. Tu (2000). Evolution in Open Source Software: A Case Study. In Proceedings 2000 International Conference on Software Maintenance (ICSM'00), pages 131–142. IEEE.

J. Goguen (1986). An Introduction to OBJ: A Language for Writing and Testing Formal Algebraic Program Specifications. In GehaniN. and McGettrickA., editors, Software Specification Techniques, pages 391–419. Addison-Wesley.

GoguenJ. and JirotkaM., editors (1994). Requirements Engineering: Social and Technical Issues. Academic PressBoston.

J. Goguen and C. Linde (1993). Techniques for Requirements Elicitation. In Proceedings 1st International Symposium on Requirements Engineering (RE93), pages 152–164, San Diego. IEEE.

J. Goodenough and S. Gerhart (1975). Toward a Theory of Test Data Selection. IEEE Transactions on Software Engineering, 1(2):156–173.

A. Gopal, M. Krishnan, T. Mukhopadhyay, and D. Goldenson (2002). Measurement Programs in Software Development: Determinants of Success. IEEE Transactions on Software Engineering, 28(9):863–875.

V. Gordon and J. Bieman (1994). Rapid Prototyping: Lessons Learned. IEEE Software, 12(1):85–95.

O. Gotel and A. Finkelstein (1994). An Analysis of the Requirements Traceability Problem. In Proceedings International Conference on Requirements Engineering, pages 94–101. IEEE.

D. Gotterbarn (1999). How the New Software Engineering Code of Ethics Affects You. IEEE Software, 16(6):58–64.

D. Gotterbarn, K. Miller, and S. Rogerson (1999). Computer Society and ACM Approve Software Engineering Code of Ethics. IEEE Computer, 32(10):84–88.

R. Grady and D. Caswell (1987). Software Metrics: Establishing a Company-Wide Program. Prentice Hall.

R. Grady and T. van Slack (1994). Key Lessons in Achieving Widespread Inspection Use. IEEE Software, 11(4):46–57.

O. Greevy, S. Ducasse, and T. Gîrba (2006). Analyzing software evolution through feature views. Journal of Software Maintenance and Evolution: Research and Practice, pages 425–456.

R. Grinter, J. Herbsleb, and D. Perry (1999). The Geography of Coordination: Dealing with Distance in R&D Work. In Proceedings GROUP'99, pages 306–315. ACM.

M. Grossman, J. Aronson, and R. McCarthy (2005). Does UML make the grade? Insights from the software development community. Information and Software Technology, 47(6):383–397.

J. Grudin (1991). Interactive Systems: Bridging the Gaps Between Developers and Users. IEEE Computer, 24(4):59–69.

R. Guindon and B. Curtis (1988). Control of Cognitive Processes during Design: What Tools Would Support Software Designers? In Proceedings CHI'88, pages 263–268. ACM.

R. Gunning (1968). The Technique of Clear Writing. McGraw-Hill.

T. Gyimóthy, R. Ferenc, and I. Siket (2005). Empirical Validation of Object-Oriented Metrics on Open Source Software for Fault Prediction. IEEE Transactions on Software Engineering, 31(10):897–910.

G. d. Haan, G. van der Veer, and J. van Vliet (1991). Formal Modelling Techniques in Human-Computer Interaction. Acta Psychologica, 78:27–67.

T. Hall and N. Fenton (1997). Implementing Effective Software Metrics Programs. IEEE Software, 14(2):55–65.

M. Halstead (1977). Elements of Software Science. North-Holland Publishing Company.

D. Hamlet and R. Taylor (1990). Partition Testing Does Not Inspire Confidence. IEEE Transactions on Software Engineering, 16(12):1402–1411.

M. Hansen (1999). The Search-Transfer Problem: The Role of Weak Ties in Sharing Knowledge across Organization Subunits. Administrative Science Quarterly, 44(1):82–111.

D. Harel (1988). On Visual Formalisms. Communications of the ACM, 31(5):514–530.

W. Harrison (2004). Clueless-and Oblivious. IEEE Software, 21(3):5–7.

M. Harrold (1999). Testing Evolving Software. Journal of Systems and Software, 47(2/3):173–181.

M. Harrold, A. Offutt, and K. Tewary (1997). An Approach to Fault Modeling and Fault Seeding Using the Program Dependence Graph. Journal of Systems and Software, 36(3):273–295.

D. Hatley and I. Pirbhai (1988). Strategies for Real-Time System Specification. Dorset House.

L. Hatton (2007). How Accurately Do Engineers Predict Software Maintenance Tasks? IEEE Computer, 40(2):64–69.

F. Heemstra (1989). How Much Does Software Cost? PhD thesis, Technical University of Eindhoven, The Netherlands. In Dutch.

G. Heineman and W. Councill (2001). Component-Based Software Engineering: Putting the Pieces Together. Addison-Wesley.

B. Henderson Sellers (1992). Modularization and McCabe's Cyclomatic Complexity. Communications of the ACM, 35(12):17–19.

S. Henri and D. Kafura (1981). Software Structure Metrics Based on Information Flow. IEEE Transactions on Software Engineering, 7(5):510–518.

J. Henry and J. Cain (1997). Comparison of Perfective and Corrective Software Maintenance. Journal of Software Maintenance: Research and Practice, 9:281–297.

J. Herbsleb (2007). Global Software Engineering: The Future of Socio-technical Coordination. In Proceedings 29th International Conference on Software Engineering (ICSE29). ACM.

J. Herbsleb and R. Grinter (1999). Architectures, Coordination, and Distance: Conway's Law and Beyond. IEEE Software, 16(5):63–70.

J. Herbsleb and A. Mockus (2003). An Empirical Study of Speed and Communication in Globally-Distributed Software Development. IEEE Transactions on Software Engineering, 29(3):1–14.

J. Herbsleb, D. Paulish, and M. Bass (2005). Global Software Development at Siemens: Experience from Nine Projects. In Proceedings 27th International Conference on Software Engineering (ICSE27), pages 524–533. IEEE.

J. Herbsleb, D. Zubrow, D. Goldenson, W. Hayes, and M. Paulk (1997). Software Quality and the Capability Maturity Model. Communications of the ACM, 40(6):30–40.

J. Highsmith (2004). Agile Project Management. Addison-Wesley.

R. Hirschheim and H. Klein (1989). Four Paradigms of Information Systems Development. Communications of the ACM, 32(10):1199–1216.

M. Hitz and B. Montazeri (1996). Chidamber and Kemerer's Metrics Suite: A Measurement Theory Perspective. IEEE Transactions on Software Engineering, 22(4):267–271.

D. Hix and H. Hartson (1993). Developing User Interfaces: Ensuring Usability Through Product and Process. John Wiley & Sons.

W. Ho and R. Olsson (1996). A Layered Model for Building Debugging and Monitoring Tools. Journal of Systems and Software, 34(3):211–222.

G. Hødalsvik and G. Sindre (1993). On the purpose of Object-Oriented Analysis. In OOPSLA'93 Proceedings, ACM SIGPLAN Notices 28 (10), pages 240–255.

H. Hofman and F. Lehner (2001). Requirements Engineering as a Success Factor in Software Projects. IEEE Software, 18(4):58–66.

C. Hofmeister, P. Kruchten, R. Nord, H. Obbink, A. Ran, and P. America (2007). A General Model of Software Architecture Design Derived from Five Industrial Approaches. Journal of Systems and Software, 80(1):106–126.

G. Hofstede (1997). Culture and Organizations. McGraw-Hill.

J. Hops and J. Sherif (1995). Development and Application of Composite Complexity Models and a Relative Complexity Metric in a Software Maintenance Environment. Journal of Systems and Software, 31(2):157–169.

W. Hosier (1961). Pitfalls and Safeguards in Real-Time Digital Systems With Emphasis on Programming. IRE Transactions on Engineering Management, pages 99–115.

W. Howden (1982). Validation of Scientific Programs. ACM Computing Surveys, 14(2):193–227.

W. Howden (1985). The Theory and Practice of Functional Testing. IEEE Software, 2(5):6–17.

W. Humphrey (1988). Characterizing the Software Process: A Maturity Framework. IEEE Software, 5(2):73–79.

W. Humphrey (1989). Managing the Software Process. SEI Series in Software Engineering. Addison-Wesley.

W. Humphrey (1996). Using a Defined and Measured Personal Software Process. IEEE Software, 13(3):77–88.

W. Humphrey (1997a). Introduction to the Personal Software Process. Addison-Wesley.

W. Humphrey (1997b). Managing Technical People. Addison-Wesley.

W. Humphrey, D. Kitson, and T. Kasse (1989). The State of Software Engineering Practice: A Preliminary Report. In Proceedings 11th International Conference on Software Engineering (ICSE11), pages 277–288. IEEE.

A. Hunt and D. Thomas (2003). Pragmatic Unit Testing. The Pragmatic Bookshelf.

IEEE610 (1990). IEEE Standard Glossary of Software Engineering Terminology. IEEE Std 610.12.

IEEE730 (1998). IEEE Standard for Software Quality Assurance Plans. IEEE Std 730.

IEEE828 (1998). IEEE Standard for Software Configuration Management Plans. IEEE Std 828.

IEEE829 (1998). IEEE Standard for Software Test Documentation. IEEE Std 829.

IEEE830 (1998). IEEE Recommended Practice for Software Requirements Specifications. IEEE Std 830.

IEEE983 (1986). IEEE Standard on Software Quality Assurance Planning. IEEE Std 983.

IEEE1012 (2004). IEEE Standard for Software Verification and Validation Plans. IEEE Std 1012.

IEEE1016 (1987). IEEE Recommended Practice for Software Design Descriptions. IEEE Std 1016.

IEEE1219 (1998). IEEE Standard for Software Maintenance. IEEE Std 1219.

IEEE1471 (2000). IEEE Recommended Practice for Architectural Description of Software-Intensive Systems. Technical report, IEEE.

J. Iivari (1996). Why are CASE tools not used? Communications of the ACM, 39(10):94–103.

InverardiP. and JazayeriM., editors (2006). Software Engineering Education in the Modern Age. Springer Verlag, LNCS 4309.

K. Ishikawa (1985). What Is Total Quality Control? The Japanese Way. Prentice Hall.

ISO 9126 (2001). ISO/IEC 9126–1: Software Engineering — Product Quality — Part 1: Quality Model. ISO.

ISO 9241 (1996). ISO DIS 9241–11, Ergonomic Requirements for Office Work with Visual Display Terminals (VDTs): — Part 11: Guidance on Usability. Technical report, ISO.

ITT (1983). Proceedings Workshop on Reusability in Programming. ITT.

M. Jackson (1975). Principles of Program Design. Academic Press.

M. Jackson (1983). System Development. Prentice Hall.

M. Jackson (2001). Problem Frames. Addison-Wesley.

D. Jankowski (1994). The Feasibility of CASE Structured Analysis Methodology Support. ACM Software Engineering Notes, 19(2):72–82.

D. Janzen and H. Saiedian (2005). Test-Driven Development: Concepts, Taxonomy, and Future Direction. IEEE Computer, 38(9):43–50.

S. Jarzabek and R. Huang (1998). The Case for User-Centered CASE Tools. Communications of the ACM, 41(8):93–98.

S. Jarzabek and G. Wang (1998). Model-based Design of Reverse Engineering Tools. Journal of Software Maintenance: Research and Practice, 10:353–380.

M. Jazayeri (2007). Some Trends in Web Application Development. In Proceedings 29th International Conference on Software Engineering (ICSE29). IEEE.

R. Jeffries, A. Anderson, and C. Hendrickson (2001). Extreme Programming Installed. Addison-Wesley.

D. Jeske and X. Zhang (2005). Some successful approaches to software reliability modeling in industry. Journal of Systems and Software, 74(1):85–100.

J.-M. Jézéquel and M. Meyer (1997). Design by Contract: The Lessons of Ariane. IEEE Computer, 30(1):129–130.

H. Johnson and P. Johnson (1991). Task Knowledge Structures: Psychological Basis and Integration into System Design. Acta Psychologica, 78:3–26.

L. Johnson (1998). A View From the 1960s: How the Software Industry Began. IEEE Annals of the History of Computing, 20(1):36–42.

P. Johnson (1989). Supporting System Design by Analyzing Current Task Knowledge. In Diaper, D., editor, Task Analysis for Human—Computer Interaction. Ellis Horwood, Chichester.

R. Johnson and B. Foote (1988). Designing Reusable Classes. Journal of Object Oriented Programming, 1(1):22–35.

A. Jonassen Hass (2002). Configuration Management Principles and Practice. Addison-Wesley.

C. Jones (1986). Programming Productivity. McGraw-Hill.

C. Jones (1989). Software Enhancement Modelling. Journal of Software Maintenance: Research and Practice, 1(2):91–100.

C. Jones (1999). The Euro, Y2K, and the US Software Labor Shortage. IEEE Software, 16(3):55–61.

C. Jones (2006). The Economics of Software Maintenance in the Twenty First Century, Version 3, February 14, 2006. Technical report, http://www.spr.com.

B. Jordan (1996). Ethnographic Workplace Studies and CSCW. In ShapiroD., TauberM., and TraunmuellerR., editors, The Design of Computer Supported Cooperative Work and Groupware Systems, pages 17–42. North-Holland, Amsterdam.

B. Jordan and A. Henderson (1995). Interaction Analysis: Foundations and Practice. The Journal of the Learning Sciences, 4(1):39–103.

P. Jordan, B. Thomas, B. Weerdmeester, and I. McClelland (1996). Usability Evaluation in Industry. Taylor & Francis, London.

M. Jørgensen (2004). A review of studies on expert estimation of software development effort. Journal of Systems and Software, 70(1–2):37–60.

M. Jørgensen (2005). Practical Guidelines for Expert-Judgment-Based Software Effort Estimation. IEEE Software, 22(3):57–63.

M. Jørgensen and S. Grimstad (2004). Over-optimism in Software Development Projects: "The winner's curse". Improve, Software Process Improvement Newsletter, (4).

M. Jørgensen, K. Teigen, and K. Moløken (2004). Better sure than safe? Over-confidence in judgement based software development effort prediction intervals. Journal of Systems and Software, 70(1–2):79–93.

JSS (1995a). Special Issue on Software Metrics. Journal of Systems and Software, 31(2).

JSS (1995b). Special Issue on Software Reuse. Journal of Systems and Software, 30(3).

N. Juristo, A. Moreno, and A. Silva (2002). Is the European Industry Moving toward Solving Requirements Engineering Problems? IEEE Software, 19(6):70–77.

N. Juristo, A. Moreno, and S. Vegas (2004). Reviewing 25 Years of Testing Technique Experiments. Empirical Software Engineering, 9:7–44.

E. Kamsties and C. Lott (1995). An Emperical Evaluation of Three Defect-Detection Techniques. In SchäferW. and BotellaP., editors, Software Engineering ESEC '95, LNCS 989, pages 362–383. Springer Verlag.

C. Kaner and W. Bond (2004). Software Engineering Metrics: What Do They Measure and How Do We Know. In Proceedings 10th International Software Metrics Symposium (Metrics 2004), pages 1–12. IEEE.

N. Kano (1993). Kano's Methods for Understanding Customer-defined Quality. Center for Quality of Management Journal, 2(4):3–36.

KarlssonE.-A., editor (1995). Software Reuse: A Holistic Approach. John Wiley & Sons.

D. Karlström and P. Runeson (2005). Combining Agile Methods with State-Gate Project Management. IEEE Software, 22(3):43–49.

G. Karner (1993). Metrics for Objectory. Technical report, Diploma Thesis, University of Linköping, LiTH-IDA-Ex-9344:21.

R. Kazman, L. Bass, and M. Klein (2006). The essential components of software architecture design and analysis. Journal of Systems and Software, 79(8):1207–1216.

P. Keen (1991). Shaping the Future: Business Design through Information Technology. Harvard Business School PressCambridge, MA.

M. Keil and E. Carmel (1995). Customer-Developer Links in Software Development. Communications of the ACM, 38(5):33–44.

C. Kemerer (1993). Reliability of Function Points Measurement. Communications of the ACM, 36(2):85–97.

C. Kemerer and B. Porter (1992). Improving the Reliability of Function Point Measurement: An Empirical Study. IEEE Transactions on Software Engineering, 18(11):1011–1024.

C. Kemerer and S. Slaughter (1997). Determinants of Software Maintenance Profiles: An Empirical Investigation. Journal of Software Maintenance: Research and Practice, 9:235–251.

B. Kernighan and J. Mashey (1981). The UNIX Programming Environment. IEEE Computer, 14(4):12–24.

D. King (1988). Creating Effective Software: Computer Program Design Using the Jackson Methodology. Yourdon Press.

B. Kirwan and L. Ainsworth (1992). A Guide to Task Analysis. Taylor & Francis, London.

B. Kitchenham, D. Jeffery, and C. Connaughton (2007). Misleading Metrics and Unsound Analysis. IEEE Software, 24(2):73–78.

B. Kitchenham and S. Pfleeger (1996). Software Quality: The Elusive Target. IEEE Software, 13(1):12–21.

B. Kitchenham, S. Pfleeger, and N. Fenton (1995). Towards a Framework for Software Measurement Validation. IEEE Transactions on Software Engineering, 21(12):929–943.

G. Klein, J. Jiang, and D. Tesch (2002). Wanted: Project Teams with a Blend of IS Professional Orientations. Communications of the ACM, 45(6):81–87.

J. Knight and P. Ammann (1985). An Experimental Evaluation of Simple Methods for Seeding Program Errors. In Proceedings 8th International Conference on Software Engineering (ICSE8), pages 337–342. IEEE.

J. Knight and E. Myers (1993). An Improved Inspection Technique. Communications of the ACM, 36(11):50–61.

D. Knuth and M. Plass (1981). Breaking Paragraphs Into Lines. Software, Practice & Experience, 11:1119–1184.

T. Kohno, A. Stubblefield, A. Rubin, and D. Wallach (2004). Analysis of an Electronic Voting System. In Proceedings IEEE Symposium on Security and Privacy, pages 27–42.

H. Koontz and C. O'Donnell (1972). Principles of Management: An Analysis of Managerial Functions. McGraw-Hill.

A. Koru and J. Tian (2005). Comparing High-Change Modules and Modules with the Highest Measurement Values in Two Large-Scale Open-Source Products. IEEE Transactions on Software Engineering, 31(8):625–642.

G. Kotonya and I. Sommerville (1997). Requirements Engineering, Processes and Techniques. John Wiley & Sons.

G. Krasner and S. Pope (1988). A cookbook for using the Model-View-Controller user interface paradigm in Smalltalk-80. Journal of Object Oriented Programming, 1(3):26–49.

R. Kraut and L. Streeter (1995). Coordination in Software Development. Communications of the ACM, 38(3):69–81.

S. Krishna, S. Sahay, and G. Walsham (2004). Managing Cross-Cultural Issues in Global Software Outsourcing. Communications of the ACM, 47(4):62–66.

J. Krogstie (1994). On the Distinction between Functional Development and Functional Maintenance. Journal of Software Maintenance: Research and Practice, 7:383–403.

P. Kruchten (1995). The 4 + 1 View Model of Architecture. IEEE Software, 12(6):42–50.

P. Kruchten (1999). The Software Architect. In Software Architecture (WICSA1), pages 563–583. Kluwer Academic Publishers.

P. Kruchten (2003). The Rational Unified Process: An Introduction. Addison-Wesley, third edition.

D. Kruglinski (1996). Inside Visual C++. Microsoft Press.

H.-J. Kung and C. Hsu (1998). Software Maintenance Life Cycle Model. In Proceedings International Conference on Software Maintenance (ICSM'98), pages 113–121.

P. Kuvaja, J. Simila, L. Krzanik, A. Bicego, G. Koch, and S. Saukonen (1994). Software Process Assessment and Improvement: the BOOTSTRAP approach. Blackwell PublishersOxford, UK.

A. v. Lamsweerde (2001). Goal-Oriented Requirements Engineering: A Guided Tour. In Proceedings 5th International Symposium on Requirements Engineering (RE'01), pages 1–13. IEEE.

R. Lanergan and C. Grasso (1984). Software Engineering with Reusable Designs and Code. IEEE Transactions on Software Engineering, 10(5):498–501.

C. Lange, M. Chaudron, and J. Muskens (2006). UML Software Architecture and Design Description. IEEE Software, 23(2):40–46.

F. Lanubile, T. Mallardo, and F. Calefato (2003). Tool Support for Geographically Dispersed Inspection Teams. Software Process Improvement and Practice, 8(4):217–231.

T. LaToza, G. Venolia, and R. DeLine (2006). Maintaining Mental Models: A Study of Developer Work Habits. In Proceedings 28th International Conference on Software Engineering (ICSE28), pages 492–501. ACM.

LaurelB., editor (1990). The Art of Human-Computer Interface Design. Addison-Wesley.

B. Laurel (1993). Computers as Theatre. Addison-Wesley.

M. Lawrence (1981). Programming Methodology, Organizational Environment, and Programming Productivity. Journal of Systems and Software, 2:257–269.

D. Lea (1994). Christopher Alexander: An Introduction for Object-Oriented Designers. ACM Software Engineering Notes, 19(1):39–46.

A. Lederer and J. Prasad (2000). Software management and cost estimating error. Journal of Systems and Software, 50(1):33–42.

D. Leffingwell and D. Widrig (2000). Managing Software Requirements — A Unified Approach. Addison-Wesley.

M. Lehman (1974). Programs, Cities and Students: Limits to Growth? Number 9 in Inaugural Lecture Series. Imperial College, London.

M. Lehman (1980). Programs, Life Cycles, and Laws of Software Evolution. Proceedings of the IEEE, 68(9):1060–1076.

M. Lehman (1987). Process Models, Process Programs, Programming Support. In Proceedings 9th International Conference on Software Engineering (ICSE9), pages 14–16. IEEE.

LehmanM. and BeladyL., editors (1985). Program Evolution. Number 27 in APIC Studies in Data Processing. Academic Press.

M. Lehman, J. Ramil, P. Wernick, D. Perry, and W. Turski (1997). Metrics and Laws of Software Evolution — The Nineties View. In Proceedings 4th International Symposium On Software Metrics (Metrics 97), pages 20–32. IEEE.

T. Lethbridge, J. Singer, and A. Forward (2003). How Software Engineers Use Documentation: The State of the Practice. IEEE Software, 20(6):35–39.

N. Leveson (1986). Software Safety: What, Why, and How. ACM Computing Surveys, 18(2):125–164.

N. Leveson (1991). Software Safety Issues in Embedded Computer Systems. Communications of the ACM, 34(2):34–46.

N. Leveson (1992). High-Pressure Steam Engines and Computer Software. In Proceedings 14th International Conference on Software Engineering (ICSE14), pages 2–14. IEEE.

N. Leveson and C. Turner (1993). An Invesigation of the Therac-25 Accidents. IEEE Computer, 26(7):18–41.

W. Li and S. Henry (1993). Object-Oriented Metrics that Predict Maintainability. Journal of Systems and Software, 23(2):111–122.

B. Lientz and E. Swanson (1980). Software Maintenance Management. Addison-Wesley.

F. v. d. Linden and J. Müller (1995). Creating Architectures with Building Blocks. IEEE Software, 12(6):51–60.

G. Lindgaard (1994). Usability Testing and System Evaluation. Chapman & Hall, London.

M. Lindvall, D. Muthig, A. Dagnino, C. Wallin, M. Stupperich, D. Kiefer, J. May, and T. Kähkönen (2004). Agile Software Development in Large Organizations. IEEE Computer, 37(12):26–34.

R. Linger, H. Mills, and B. Witt (1979). Structured Programming: Theory and Practice. Addison-Wesley.

J. Lions (1996). Ariane 5 Flight 501 Failure: Report by the Inquiry Board. Technical report, http://www.cs.vu.nl/ hans/ariane5report.html.

C. Lott (1993). Process and Measurement Support in SEEs. ACM Software Engineering Notes, 18(4):83–93.

P. Loucopoulos and V. Karakostas (1995). Systems Requirements Engineering. McGraw-Hill.

M. Lubars, G. Meredith, C. Potts, and C. Richter (1992). Object-Oriented Analysis for Evolving Systems. In Proceedings 14th International Conference on Software Engineering (ICSE14), pages 173–185. IEEE.

B. Lundell and B. Lings (2004). Changing perceptions of CASE technology. Journal of Systems and Software, 72(2):271–280.

M. Lyons (1981). Salvaging Your Software Asset (Tools Based Maintenance). In AFIPS Conference Proceedings, volume 50, pages 337–341.

LyuM., editor (1995). Handbook of Software Reliability Engineering. McGraw-Hill.

R. Macala, L. Stuckey, Jr., and D. Gross (1996). Managing Domain-Specific, Product-Line Development. IEEE Software, 13(3):57–68.

A. MacLean, R. Young, V. Bellotti, and T. Moran (1991). Questions, Options, and Criteria: Elements of Design Space Analysis. Human-Computer Interaction, 6:201–250.

A. Macro and J. Buxton (1987). The Craft of Software Engineering. Addison-Wesley.

N. Maiden, A. Gizikis, and S. Robertson (2004). Provoking Creativity: Imagine What Your Requirements Could Be Like. IEEE Software, 21(5):68–75.

N. Maiden and C. Ncube (1998). Acquiring COTS Software Selection Requirements. IEEE Software, 15(2):46–56.

M. Mäntylä, J. Vanhanen, and C. Lassenius (2003). A Taxonomy and an Initial Empirical Study of Bad Smells in Code. In Proceedings International Conference on Software Maintenance (ICSM'03), pages 381–384.

J. Maranzano, S. Rozsypal, G. Zimmerman, G. Warnken, P. Wirth, and D. Weiss (2005). Architecture Reviews: Practice and Experience. IEEE Software, 22(2):34–43.

T. Margaria and B. Steffen (2006). Service Engineering: Linking Business and IT. IEEE Computer, 39(10):45–55.

J. Martin (1991). Rapid Application Development. MacMillan.

R. Martin (2002). Agile Software Development, Principles, Patterns and Practices. Prentice Hall.

R. Martin and W. Osborne (1983). Guidance on Software Maintenance. National Bureau of Standards, Washington. NBS Special Publication 500–106.

R. Mata-Toledo and D. Gustafson (1992). A Factor Analysis of Software Complexity Measures. Journal of Systems and Software, 17(3):267–273.

N. Matloff (2005). Offshoring: What Can Go Wrong? IT Pro, July/August:39–45.

E. Maximilien and L. Williams (2003). Assessing Test-Driven Development at BM. In Proceedings 25th International Conference on Software Engineering (ICSE25), pages 564–569. IEEE.

J. May and P. Barnard (1995). Cinematography and Interface Design. In NordbyK. et al., editors, Human-Computer Interaction: Proceedings Interact'95, pages 26–31. Chapman and Hall.

D. Mayhew (1992). Principles and Guidelines in Software User Interface Design. Prentice Hall.

A. v. Mayrhauser and A. Vans (1995). Program Comprehension During Software Maintenance and Evolution. IEEE Computer, 28(8):44–55.

A. v. Mayrhauser, A. Vans, and A. Howe (1997). Program Understanding Behaviour during Enhancement of Large-scale Software. Journal of Software Maintenance: Research and Practice, 9:299–327.

M. Maznevski and K. Chudoba (2000). Bridging Space Over Time: Global Virtual Team Dynamics and Effectiveness. Organization Science, 11(5):473–492.

T. McCabe (1976). A Complexity Measure. IEEE Transactions on Software Engineering, 2(4):308–320.

J. McCall, P. Richards, and G. Walters (1977). Factors in Software Quality. Technical Report RADC-TR-77–369, US Department of Commerce.

R. McClure (1968). Production-Management Aspects. In Naur and Randell (1968), page 72.

S. McConnell (2006). Software Estimation: Demystifying the Black Art. Microsoft Press.

D. McCracken and M. Jackson (1981). A Minority Dissenting Position. In CottermanW. et al., editors, Systems Analysis and Design: A foundation for the 1980's, pages 551–553. North Holland.

C. McDowell, L. Werner, H. Bullock, and J. Fernald (2006). Pair Programming Improves Student Retention, Confidence, and Program Quality. Communications of the ACM, 49(8):90–95.

M. McIlroy (1968). Mass-Produced Software Components. In Naur and Randell (1968), pages 88–98.

N. Medvidovic and R. Taylor (1997). A Framework for Classifying and Comparing Architecture Description Languages. In JazayeriM. and SchauerH., editors, Proceedings 6th European Software Engineering Conference, LNCS 1301, pages 60–76. Springer Verlag.

N. Medvidovic and R. Taylor (2000). A Classification and Comparison Framework for Software Architecture Description Languages. IEEE Transactions on Software Engineering, 26(1):70–93.

T. Mens and T. Tourwé (2004). A Survey of Software Refactoring. IEEE Transactions on Software Engineering, 30(2):126–139.

T. Meservy and K. Fenstermacher (2005). Transforming Software Development: An MDA Road Map. IEEE Computer, 38(9):52–58.

P. Metzger (1987). Managing Programming People. Prentice Hall.

B. Meyer (1985). On Formalism in Specifications. IEEE Software, 2(1):6–26.

B. Meyer (1992). Design by Contract. IEEE Computer, 25(10):40–51.

B. Meyer (1996). Reality: A cousin twice removed. IEEE Computer, 29(7):96–97.

H. Mili, A. Mili, S. Yacoub, and E. Addy (2002). Reuse-Based Software Engineering. Wiley.

B. Miller, L. Fredrikson, and B. So (1990). An Experimental Study of the Reliability of UNIX Facilities. Communications of the ACM, 33(12):32–44.

H. Mills, M. Dyer, and R. Linger (1987). Cleanroom Software Engineering. IEEE Software, 4(5):19–25.

H. Mintzberg (1983). Structures in Fives: Designing Effective Organizations. Prentice Hall.

A. Mockus, R. Fielding, and J. Herbsleb (2000). A Case Study of Open Source Software Development: The Apache Server. In Proceedings 22nd International Conference on Software Engineering (ICSE22), pages 263–272. IEEE.

P. Mohagheghi, B. Anda, and R. Conradi (2005). Effort Estimation of Use Cases for Incremental Large-Scale Software Development. In Proceedings 27th International Conference on Software Engineering (ICSE27), pages 303–311. IEEE.

T. Moran (1981). The Command Language Grammar: A Representation of the User Interface of Interactive Computer Systems. International Journal of Man-Machine Studies, 15(1):3–50.

T. Moran and J. Carroll (1994). Design Rationale: Concepts, Techniques, and Use. Lawrence Erlbaum Associates.

T. Moran and J. Carroll (1996). Design Rationale: Concepts, Techniques and Use. Lawrence Erlbaum Associates, New Jersey.

M. Morisio, M. Ezran, and C. Tully (2002a). Success and Failure Factors in Software Reuse. IEEE Transactions on Software Engineering, 28(4):340–357.

M. Morisio, C. Seaman, V. Basili, A. Parra, S. Kraft, and S. Condon (2002b). COTS-based software development: Processes and open issues. Journal of Systems and Software, 61(3):189–199.

R. Motschnig-Pitrik (1996). Analyzing the Notions of Attribute, Aggregate, Part and Member in Data/Knowledge Modeling. Journal of Systems and Software, 33(2):113–122.

T. Moynihan (1996). An Experimental Comparison of Object-Orientation and Functional-Decomposition as Paradigms for Communicating System Functionality to Users. Journal of Systems and Software, 33(2):163–170.

T. Moynihan (2000). Coping with 'requirements-uncertainty': the theories-of-action of experienced IS/software project managers. Journal of Systems and Software, 53(2):99–109.

R. Mulligan, M. Altom, and D. Simkin (1991). User Interface Design in the Trenches: Some Tips on Shooting from the Hip. In Proceedings CHI'91, pages 232–236. ACM.

J. Musa, A. Iannino, and K. Okumoto (1987). Software Reliability: Measurement, Prediction, Application. McGraw-Hill.

J. Muskens, M. Chaudron, and J. Lukkien (2005). A Component Framework for Consumer Electronics Middleware. In AtkinsonC., BunseC., PeperC., and GrossH.-G., editors, Component-Based Software Development for Embedded Systems. Springer, LNCS 3778.

G. Mustapic, A. Wall, C. Norström, I. Crnkovic, K. Sandström, J. Fröberg, and J. Andersson (2004). Real World Influences on Software Architecture — Interviews with Industrial System Experts. In Proceedings 4th Working IEEE/IFIP Conference on Software Architecture (WICSA4), pages 101–111. IEEE.

B. Myers and M. Rosson (1992). Survey on User Interface Programming. In Human Factors in Computing Systems, Proceedings SIGCHI'92, pages 195–202. ACM.

G. Myers (1979). The Art of Software Testing. John Wiley & Sons.

G. Myers (2004). The Art of Software Testing. Wiley, second edition.

W. Myers (1986). Can Software for the SDI ever be Error-Free? IEEE Computer, 19(10):61–67.

W. Myers (1988). Shuttle Code Achieves Very Low Error Rate. IEEE Software, 5(5):93–95.

J. Mylopoulos, L. Chung, S. Liao, H. Wang, and E. Yu (2001). Exploring Alternatives during Requirements Analysis. IEEE Software, 18(1):92–96.

NardiB., editor (1995). Context and Consciousness: Activity Theory and Human Computer Interaction. MIT PressCambridge MA.

NaurP. and RandellB., editors (1968). Software Engineering: Report on a Conference. NATO Scientific Affairs Division, Garmisch.

E. Nelson (1966). Management Handbook for the Estimation of Computer Programming Costs. Systems Development Corp. AD-A648750.

U. Nerurkar (2001). Web User Interface Design: Forgotten Lessons. IEEE Software, 18(6):69–71.

P. Neumann (1995). Computer-Related Risks. Addison-Wesley.

P. Neumann (2004). The Problems and Potentials of Voting Systems. Communications of the ACM, 47(10):29–30.

W. M. Newman and M. G. Lamming (1995). Interactive System Design. Addison-Wesley.

J. Nielsen (1993). Usability Engineering. Academic Press.

J. Nielsen and R. Mack (1994). Usability Inspection Methods. John Wiley & Sons.

F. Niessink and H. van Vliet (1997). Predicting Maintenance Effort with Function Points. In Proceedings International Conference on Software Maintenance (ICSM'97), pages 32–39. IEEE.

F. Niessink and H. van Vliet (1998a). Towards Mature IT Services. Software Process — Improvement and Practice, 4(2):55–71.

F. Niessink and H. van Vliet (1998b). Towards Mature Measurement Programs. In NesiP. and LehnerF., editors, Proceedings 2nd Euromicro Conference on Software Maintenance and Reengineering, pages 82–88. IEEE.

F. Niessink and H. van Vliet (1999). Software Maintenance from a Service Perspective. Technical report, Vrije Universiteit.

P. Norden (1970). Useful Tools for Project Management. In Starr, M., editor, Management of Production, pages 71–101. Penguin Books.

D. Norman (1983). Some Observations on Mental Models. In GentnerD. and StevensA., editors, Mental Models, pages 7–14. Erlbaum.

J. Nosek and P. Palvia (1990). Software Maintenance Management: Changes in the Last Decade. Journal of Software Maintenance: Research and Practice, 2(3):157–174.

A. Offutt, M. Harrold, and P. Kolte (1993). A Software Metric System for Module Coupling. Journal of Systems and Software, 20(3):295–308.

A. Offutt and S. Lee (1994). An Emperical Evaluation of Weak Mutation. IEEE Transactions on Software Engineering, 20(5):337–344.

G. Olson and J. Olson (2000). Distance Matters. Human-Computer Interaction, 15(2/3):139–178.

R. v. Ommering, F. van der Linden, J. Kramer, and J. Magee (2000). The Koala Component Model for Consumer Electronics Software. IEEE Computer, 33(3):78–85.

W. Orlikowski (1992). Learning from Notes: Organizational Issues in Groupware Implementation. In Proceedings ACM Conference on Customer-Supported Cooperative Work (CSCW'92). ACM.

I. Oshri, J. Kotlarsky, and L. Willcocks (2007). Global software development: Exploring socialization and face-to-face meetings in distributed strategic projects. Journal of Strategic Information Systems, 16:25–49.

L. Osterweil (1987). Software Processes Are Software Too. In Proceedings 9th International Conference on Software Engineering (ICSE9), pages 2–13. IEEE.

E. Oz (1994). When Professional Standards are Lax: The CONFIRM Failure and its Lessons. Communications of the ACM, 37(10):29–36.

M. Paasivara and C. Lassenius (2006). Could Global Software Development Benefit from Agile Methods? In Proceedings International Conference on Global Software Engineering (ICGSE'06). IEEE.

D. Page, P. Williams, and D. Boyd (1993). Report of the Inquiry into the London Ambulance Service. South West Thames Regional Health Authority.

M. Papazoglou (2008). Web Services: Principles and Technology. Pearson.

M. Papazoglou, P. Traverso, S. Dustdar, and F. Leymann (2006). Service-Oriented Computing: Research Roadmap. In Dagstuhl Seminar Proceedings 05462, Service Oriented Computing, http://drops.dagstuhl.de/opus/volltexte/2006/524.

M. Papazoglou and W.-J. van den Heuvel (2006). Service-oriented design and development methodology. International Journal of Web Engineering and Technology, 2(4):412–442.

D. Parnas (1972). On the Criteria to be Used in Decomposing Systems Into Modules. Communications of the ACM, 15(12):1053–1058.

D. Parnas (1978). Designing Software for Ease of Extension and Contraction. In Proceedings 3rd International Conference on Software Engineering (ICSE3), pages 264–277. IEEE.

D. Parnas (1985). Software Aspects of Strategic Defense Systems. ACM Software Engineering Notes, 10(5):15–23.

D. Parnas (1987). SDI 'Red Herrings' Miss the Boat. IEEE Computer, 20(2):6–7.

D. Parnas and P. Clements (1986). A Rational Design Process: How and Why to Fake it. IEEE Transactions on Software Engineering, 12(2):251–257.

D. Parnas and M. Lawford (2003a). Inspection's Role in Software Quality Insurance. IEEE Software, 20(4):16–20.

D. Parnas and M. Lawford (2003b). The Role of Inspection in Software Quality Assurance. IEEE Transactions on Software Engineering, 29(8):674–676.

D. Parnas and D. Weiss (1987). Active Design Reviews: Principles and Practices. Journal of Systems and Software, 7(4):259–265.

A. Parrish and S. Zweben (1995). On the Relationships Among the All-Uses, All-DU-Paths, and All-Edges Testing Criteria. IEEE Transactions on Software Engineering, 21(12):1006–1009.

S. Patel, W. Chu, and R. Baxter (1992). A Measure for Composite Module Cohesion. In Proceedings 14th International Conference on Software Engineering (ICSE14), pages 38–48. IEEE, Melbourne.

S. Payne and T. Green (1989). Task-Action Grammar: The model and its Developments. In Diaper, D., editor, Task Analysis for Human-Computer Interaction, pages 75–105. Ellis Horwood, Chichester.

C. Peltz (2003). Web Services Orchestration and Choreography. IEEE Computer, 36(10):46–53.

D. Perry and G. Kaiser (1991). Models of Software Development Environments. IEEE Transactions on Software Engineering, 17(3):283–295.

D. Perry, N. Staudenmayer, and L. Votta (1994). People, Organizations, and Process Improvement. IEEE Software, 11(4):36–45.

D. Perry and A. Wolf (1992). Foundations for the Study of Software Architecture. ACM Software Engineering Notes, 17(4):40–52.

L. Peter and R. Hull (1970). The Peter Principle. Pan Books.

J. Peterson (1981). Petri Net Theory and the Modelling of Systems. Prentice Hall.

H. Petroski (1994). Design Paradigms: Case Histories of Error and Judgment in Engineering. Cambridge University Press.

PfaffG., editor (1985). User Interface Management Systems. Springer Verlag.

S. Pfleeger (1995). Maturity, Models and Goals: How to Build a Metrics Plan. Journal of Systems and Software, 31(2):143–155.

S. Pfleeger (2000). Risky business: what we have yet to learn about risk management. Journal of Systems and Software, 53(3):265–273.

T. Pigoski (1996). Practical Software Maintenance. John Wiley & Sons.

K. Pohl (1993). The Three Dimensions of Requirements Engineering. In RollandC., BodartF., and CauvetC., editors, Proceedings Fifth International Conference on Advanced Information Systems Engineering (CAISE'93), pages 275–292. Springer Verlag.

K. Pohl, G. Böckle, and F. van der Linden (2005). Software Product Line Engineering. Springer Verlag.

A. Porter, H. Siy, A. Mockus, and L. Votta (1998). Understanding the Sources of Variation in Software Inspections. ACM Transactions on Software Engineering and Methodology, 7(1):41–79.

A. Porter, H. Siy, C. Toman, and L. Votta (1997). An Experiment to Assess the Cost-Benefits of Code Inspections in Large Scale Software Developments. IEEE Transactions on Software Engineering, 23(6):329–346.

A. Porter, L. Votta, Jr., and V. Basili (1995). Comparing Detection Methods for Software Requirements Inspections: A Replicated Experiment. IEEE Transactions on Software Engineering, 21(6):563–575.

G. Post, A. Kagan, and R. Keim (1998). A Comparative Evaluation of CASE Tools. Journal of Systems and Software, 44(2):87–96.

R. Poston (1987). Preventing Most-Probable Errors in Requirements. IEEE Software, 4(5):81–83.

C. Potts (1993). Software-Engineering Research Revisited. IEEE Software, 10(5):19–28.

J. Poulin (1999). Reuse: Been There, Done That. Communications of the ACM, 42(5):98–100.

PowerL. and WeissZ., editors (1987). Addendum to the Proceedings of OOPSLA87. ACM.

R. Prieto-Diaz (1991a). Implementing Faceted Classification for Software Reuse. Communications of the ACM, 34(5):88–97.

R. Prieto-Diaz (1991b). Making Software Reuse Work: An Implementation Model. ACM Software Engineering Notes, 16(3):61–68.

R. Prieto-Diaz (1993). Status Report: Software Reusability. IEEE Software, 10(3):61–66.

R. Prieto-Diaz and J. Neighbors (1986). Module Interconnection Languages. Journal of Systems and Software, 6:307–334.

J. Procaccino, J. Verner, and S. Lorenzet (2006). Defining and Contributing to Software Development Success. Communications of the ACM, 49(8):79–83.

L. Putnam (1978). A General Empirical Solution to the Macro Software Sizing and Estimating Problem. IEEE Transactions on Software Engineering, 4(4):345–361.

Raba (2004). Trusted Agent Report Diebold AccuVote-TS Voting System. RABA Technologies.

M. Rahgozar and F. Oroumchian (2003). An effective strategy for legacy systems evolution. Journal of Software Maintenance and Evolution: Research and Practice, 15:325–344.

A. Rainer and T. Hall (2003). A quantitative and qualitative analysis of factors affecting software processes. Journal of Systems and Software, 66(1):7–22.

N. Ramasubbu, M. Krishnan, and P. Kompalli (2005). Leveraging Global Resources: A Process Maturity Framework for Managing Distributed Development. IEEE Software, 22(3):80–86.