Effectiveness of Scrum and Kanban on Agile-Based Software Maintenance Projects

Software maintenance is an important phase in the lifespan of a software system. This chapter examines the effectiveness of Scrum and Kanban methods in terms of their impacts on project management factors for a software maintenance project. The six-point star model defines project management factors like schedule, scope, budget, risk, resources, quality, and study, and uses two other non-quantitative techniques such as team commitment and work organization. A quantitative survey was carried out together with the questionnaire distributed to IT industry professionals in Sri Lanka. Each question in the questionnaire was related to one of the above factors. The Pearson correlation coefficient was used to find the correlation between the coefficients. A strong correlation was identified. Based on the results of multiple linear regression modeling, a model has been proposed. Scrum-based software maintenance projects can improve project quality by managing work organization and resources whereas Kanban-based can improve project quality by controlling the risk and scope of the project.

Investigating Software Testing Practices in Software Development Organizations

Software testing, which is a knowledge-intensive and collaborative activity, is a sub-area of software engineering. Software testing knowledge can be applied to different testing tasks and purposes. Since software development is an error-prone task, in order to achieve quality software products, validation and verification should be carried throughout the development. This study, using qualitative methods, investigates the current practice of software testing practices in two software companies on the basis that they both claimed to apply software testing practices in their software development work. Interview results revealed some interesting latest trends in software testing from both companies.

Framework for Reusable Test Case Generation in Software Systems Testing

Agile methodologies have become the preferred choice for modern software development. These methods focus on iterative and incremental development, where both requirements and solutions develop through collaboration among cross-functional software development teams. The success of a software system is based on the quality result of each stage of development with proper test practice. A software test ontology should represent the required software test knowledge in the context of the software tester. Reusing test cases is an effective way to improve the testing of software. The workload of a software tester for test-case generation can be improved, previous software testing experience can be shared, and test efficiency can be increased by automating software testing. In this chapter, the authors introduce a software testing framework (STF) that uses rule-based reasoning (RBR), case-based reasoning (CBR), and ontology-based semantic similarity assessment to retrieve the test cases from the case library. Finally, experimental results are used to illustrate some of the features of the framework.

Applying Software Engineering Design Principles to Agile Architecture

Most enterprise IT systems are very complex with a combination of COBOL and Java programs running on multiple platforms. What is needed is a solid IT architecture that supports the operation and growth of a cross-platform IT system. It must enable the iterative and incremental development of applications that are foreseen in an agile development process. The design concept of such an architecture with its infrastructure and development tool is presented in this chapter. This design concept is based on the design principles and architectural patterns of software engineering. The architecture is a combination of layered, component-based, and service-oriented architectural patterns. The agile development process is based on a model-driven approach. The architecture and development approaches were first introduced in 2004. Since then, many applications have been developed on time and within budget.

Structural Data Binding for Agile Changeability in Distributed Application Integration

The interaction of distributed applications raises an integration problem that consists in how to satisfy the minimum interoperability requirements while reducing coupling as much as possible. Current integration technologies, such as Web Services and RESTful APIs, solve the interoperability problem but usually entail more coupling than required by the interacting applications. This is caused by sharing data schemas between applications, even if not all features of those schemas are actually exercised. This has its toll in application development agility. This chapter proposes compliance and conformance as the concepts to minimize coupling without impairing interoperability by sharing only the subset of the features of the data schema that are actually used. In addition, data binding between messages and the receiver's schema is done structurally in a universal and application-independent way. This eliminates the need for application-specific stubs and allows clients to use any server with which they comply and servers to replace any server to which they conform.

Knowledge Transfer Between Senior and Novice Software Testers

Software testing is a sub-activity of software engineering, and it is also a knowledge-intensive activity. Software testing experts need to gather domain knowledge to be able to successfully test and deliver a software system. In particular, novice software testers, who have joined the company, need to acquire enough knowledge to perform their tasks. Since software development is an error-prone task, in order to achieve quality software products, validation and verification should be carried throughout the development. This means that knowledge transfer to novice software testers must be quickly and effectively performed to facilitate the onboarding process. One way to understand the knowledge transfer process is by analyzing the software development context and the involved team members. This study, using qualitative methods, investigates the current practice of knowledge transfer in software testing practices in one software company.

Teaching Property-Based Testing

Given the large dimensions of software algorithms, the creation of unit test sets is both very difficult to use as an assurance of software quality and also very resource consuming. Some of the industry has already focused on this issue, and several methods are being used to cope with traditional testing shortcomings. Property-based testing has been one of these techniques and has been gaining traction, mainly due to the shift to functional programming techniques which can be seen in most of the popular languages and platforms. To give students tools that can increase the quality of their production as software developers, property-based testing has been taught in the Advanced Programming Techniques course of the master's program in Informatics Engineering of the Instituto Superior de Engenharia do Porto.

Reuse in Agile Development Process

Reusability is a clear principle in software development. However, systematic reuse of software elements is not common in most organizations. Application programmers rarely design and create software elements for possible future reuse. In many agile software development processes, the project teams believe that the development of reusable software elements can slow down the project. This can be a misconception. This chapter examines various ways to reuse software. Three approaches to developing reusable software artifacts from 15 years of experience in the agile development process are presented. The first approach is to create generic programs or configurable frameworks that support similar solutions for a variety of use cases and environments. The reuse of patterns is the second approach presented. Another effective way is to use a model-driven approach with model patterns. These approaches help to speed deployment software. The final product is flexible and can easily be adapted to changes. This is one of the main goals of an agile approach.

Product Backlog and Requirements Engineering for Enterprise Application Development

The combination of software engineering and agile development process can bring great benefits to the development and maintenance of enterprise applications. This chapter introduces the engineering of requirements in an agile Scrum development process. In Scrum, requirements are usually defined as user stories in a product backlog. Since many enterprise applications do not have intensive user actions, stories cannot be linked to users. Topics such as user and enabler stories, non-functional requirements, considerations of architecture and business components, business workflow, and breakdown of user stories are addressed. The requirements engineering of PBIs is illustrated by practical examples. Using UML use cases and collaboration models is recommended to transform the stories in the product backlog into formal requirements specifications. The proposed approach can be part of the agile development framework for flexible software products that are easy to customize and maintain.

Software Testing

Testing software is a process of program execution with the intent to find errors. For this purpose, various testing techniques have been used over time. Testing software is an intensive field of research in which much development work has been done. This field will become increasingly important in the future. There are many techniques for software testing. This chapter gives an overview of the entire range of software testing with suggestions for their implementation. One focus is on testing in an agile development process why the different types of software tests are important, and their cycle and methodology are described. In addition, different levels, types, and a comparative study on different types of tests are presented. The chapter also includes suggestions for performing the various tests and an effective approach to testing a software system.