Abstract
Agile software development methodologies are attracting attention from academics and practitioners for planning and managing software projects. The eXtreme Programming (XP) challenges conformist wisdom regarding software system development processes and practices as agile methodologies. To work efficiently in the current software development practice, characterized by requirements fuzziness, XP moves away from document-centric operations into people-centric management. In the XP-based software project, the customers play an essential role, having multiple responsibilities such as driving the project, gathering requirements (‘user stories'), and exercising quality control (or acceptance testing). Besides, the customers must liaise with external project stakeholders (e.g., funding authorities, end-users) while maintaining the development team's trust and the wider business. The success of such software project management practices relies on the quality result of each stage of development obtained through rigorous testing. This chapter describes three characteristics of XP project management: customer role, software testing feedback, and learning.
TopIntroduction
Modern software system plays a vital role in shaping significant social challenges (Pal, 2019). Software is increasingly an essential value-adding component of most consumer products (e.g., mobile phones, music systems, automobiles). Besides, software systems are also heavily used in the aerospace industry, enterprise business process automation, and industrial control systems. In these software applications, malfunction or error can cause loss of life or injury. Hence, error-free software function is crucial to the safety and wellbeing of people and succeeding with business operations. Succeeding with software systems means making the best use of analysis and design technology to fulfil the client's business goals and objectives. In this context, one can use the term technology to encompass all aspects of software engineering, from programming languages to analysis-and-design methods to productivity and quality. All these things encompass good software engineering practices.
It is worth considering the history that forms the basic understanding of good software engineering practices. This history is essential because the basics have been ignored in many 1990s business organizations seeking to build large and complex software systems. There is an increasing need for applying strict design principles like engineering disciplines (e.g., mechanical engineering, civil engineering) to the development of software systems (Pal, 2020) (Pal & Karakostas, 2021). Different software development process models (e.g., Waterfall, Spiral, Incremental) were introduced in recent decades, and these models provide a systematic and organized approach to software development (Sommerville, 2019). One of the critical phases in software process models is to test product correctness. This way, software products must be verified against their user requirements throughout the development process like any engineering product. Consequently, software development needs rigorous testing.
In recent times, rapid change has been an essential factor of both commercial and public life. The other crucial truism is that information technology (e.g., hardware, software, data communication networking protocols), specifically, is an integral part of many organizations and their regular operations. It is also evident (Pal, 2019) that the developers of this software need to consider design in a systematic way. Also, the burden to develop new application software support for rapidly changing processes is causing many problems for the software development community. In the recent past, traditional software design and development projects have failed many times to deliver what is needed at the cost and within the required timescale (Pal. 2020). The pressure to develop new software support for rapidly changing processes is causing severe problems for the software system development.
This is caused by some attitudinal and structural problems related to traditional software engineering. Academic and practitioners put forward some insights into the problems (Sommerville, 2019) (Pressman, 2005) and present a survey of traditional software engineering, which documents many current approaches. Besides, others such as Gilb (1988) and Beck (1999) are beginning to question how software engineering has been carried out in practical problems.
Software engineering practitioners such as Beck realize that everything about traditional software processes needs to organize in a new way. Also, Gilb and Beck proposed practices involve several well-established and reliable techniques that have been around for years. It is not just a matter of reorganizing around a few traditional techniques into different order; instead, it is a new combination of activities based on a new and very encouraging philosophy of agile software development.
Key Terms in this Chapter
Customer: The person, or persons, who pay for the software product and other services (e.g., installation, amendments, user training).
Scrum: An agile process framework for managing knowledge work, with an emphasis on software development.
Test Design Specification: A document describing the specifications of the test plan for a software characteristic or combination of software characteristics and finding the related tests.
Software Engineering: Development of software based on theoretical foundations and practical disciplines traditional to engineering.
Outputs: Describes the results of executing the function (e.g., effect on stored data, completion status values or output parameters, screen display, or outputs that trigger other actions – such as mechanical, electrical, or other activities in process control software applications).
Critical Software Systems: Software whose failure would impact safety or cause large financial or social losses.
Test Case Specification: A document specifying inputs, predicted outputs, and a set of execution conditions for a test item.
Inputs: Identifies and describes all data needed for the appropriate processing of the function of a software system.
Software Project Management: A software project can be seen as a collection of activities that create an identifiable value outcome. In its simplest form, project management consists of planning, execution, and monitoring these activities. Description of the work (tasks) and the resources (e.g., time, people, materials) needed to accomplish goals and objectives. The plan's task corresponds to the selected process model.
Agile Software Methodology: Agile software development represents a new type of approach for planning and managing software projects. It put less importance on up-front plans and strict control and relies more on information collaboration, coordination, and learning. In other words, it is an evolutionary and iterative approach to software development with focuses on adaption to changes.
User: The person, or persons, who uses (or operates, interacts) directly with the software product. The user(s) and the customer(s) are often not the same person(s).
Software Testing: Examining a software artefact to detect differences between existing and required conditions.
Test Plan: A document describing the objective, method, resources required, and plan of intended testing events. It finds test items, the features to be tested, the testing tasks, who do each task, and any risks requiring contingency planning.