Entire Software Development Life Cycle Research Articles

Measuring and improving software testability at the design level

ContextThe quality of software systems is significantly influenced by design testability, an aspect often overlooked during the initial phases of software development. The implementation may deviate from its design, resulting in decreased testability at the integration and unit levels. ObjectiveThe objective of this study is to automatically identify low-testable parts in object-orientated design and enhance them by refactoring to design patterns. The impact of various design metrics mainly coupling (e.g., fan-in and fan-out) and inheritance (e.g., depth of inheritance tree and number of subclasses) metrics on design testability is measured to select the most appropriate refactoring candidates. MethodThe methodology involves creating a machine learning model for design testability prediction using a large dataset of Java classes, followed by developing an automated refactoring tool. The design classes are vectorized by ten design metrics and labeled with testability scores calculated from a mathematical model. The model computes testability based on code coverage and test suite size of classes that have already been tested via automatic tools. A voting regressor model is trained to predict the design testability of any class diagram based on these design metrics. The proposed refactoring tool for dependency injection and factory method is applied to various open-source Java projects, and its impact on design testability is assessed. ResultsThe proposed design testability model demonstrates its effectiveness by satisfactorily predicting design testability, as indicated by a mean squared error of 0.04 and an R2 score of 0.53. The automated refactoring tool has been successfully evaluated on six open-source Java projects, revealing an enhancement in design testability by up to 19.11 %. ConclusionThe proposed automated approach offers software developers the means to continuously evaluate and enhance design testability throughout the entire software development life cycle, mitigating the risk of testability issues stemming from design-to-implementation discrepancies.

Performance Engineering: The Crucial Step for Optimized System

Performance engineering refers to the systematic discipline of engineering systems and software to meet performance requirements. The goal is to build systems that provide excellent speed, scalability, reliability, and resource usage to end users under current and projected workloads. Performance engineering applies scientific principles and methods throughout the entire software development lifecycle to proactively address performance issues before they negatively impact end users. It seeks to build peak performance capabilities into systems by design right from the start.

Multi-Objective Modified Particle Swarm Optimization for Test Suite Reduction (MOMPSO)

Software testing plays a pivotal role in entire software development lifecycle. It provides researchers with extensive opportunities to develop novel methods for the optimized and cost-effective test suite Although implementation of such a cost-effective test suite with regression testing is being under exploration still it contains lot of challenges and flaws while incorporating with any of the new regression testing algorithm due to irrelevant test cases in the test suite which are not required. These kinds of irrelevant test cases might create certain challenges such as code-coverage in the test suite, fault-tolerance, defects due to uncovered-statements and overall-performance at the time of execution. With this objective, the proposed a new Modified Particle Swarm optimization used for multi-objective test suite optimization. The experiment results involving six subject programs show that MOMPSO method can outer perform with respect to both reduction rate (90.78% to 100%) and failure detection rate (44.56% to 55.01%). Results proved MOMPSO outperformed the other stated algorithms.

Comparative Study between Lean Six Sigma and Lean-Agile for Quality Software Requirement

Requirement Elicitation is one of the challenging phases in the entire software development life cycle. It is the process of extracting and analyzing the requirements from customers to understand thoroughly of what system needs to be built. Despite all the advances in methodologies and practice approaches, extracting and establishing the right requirements are still part of the research debate. The objective of this paper is to compare the characteristics of two hybrid development approaches; Lean Six Sigma vs. Lean Agile. Most of the comparative studies done by most of the research compared within its relative knowledge such as; Lean vs. Six Sigma, Define-Measure-Analyze-Improve-Control vs. Design-For-Six-Sigma or Lean vs. Six Sigma vs Lean Six Sigma. Whereas in software industries, the comparative studies were focused on Lean vs. Agile, Agile vs. Waterfall, Lean vs. Kanban vs. Agile, which compared the project size, process cycle time, sequential or iterative process. The following parts of the study is to explore the differences and similarities in principles and practices. The study contributes significantly to the business analysts to systematically address the solutions and actions to ensure continuous improvement in producing quality software requirement.

A Model Transformation Methodology for Security Integration and Code Generation from Sequence Diagram of System's Internal Behavior

Recently, there have been many researches suggesting the inclusion of the security engineering in an early stage of system’s modeling and development of Model Driven Engineering (MDE). This concept consists in deploying Unified Modeling Language (UML) standard as a principal meta-model for different system’s abstractions. Although, most of these works have been addressing the security injection without taking into the account security infrastructure generation, generating the code corresponding to the functional and non-functional aspect at the same time. In this current work, authors have concentrated their efforts on non-functional aspects such as the business logic layer, data flow monitoring, and delivering high-quality services by developing a generic methodology for the security integration and the code generation that consider the security needs during the whole cycle of system development. Practically, a new UML profile for security integration and code generation for Java platforms has been proposed to improve the elements of the source model of Platform Independent Model (PIM) with the security integration rules for the verification and the validation of security policies, and to establish the mapping between annotated elements and the corresponding stereotypes, during the transition from CIM to PIM. The semantic definition of security was made literally by applying Larman’s new operation contracts semantics and security patterns, and concretely by applying the security formalism that was given through the new security metamodel. Finally, the objective is to improve the software applications productivity, interoperability, and generalize security integration on the entire software development life cycle rather than on the implementation phase.

Hybrid Data Approach for Selecting Effective test Cases During the Regression Testing

Abstract In the software industry, software testing becomes more important in the entire software development life cycle. Software testing is one of the fundamental components of software quality assurances. Software Testing Life Cycle (STLC)is a process involved in testing the complete software, which includes Regression Testing, Unit Testing, Smoke Testing, Integration Testing, Interface Testing, System Testing & etc. In the STLC of Regression testing, test case selection is one of the most important concerns for effective testing as well as cost of the testing process. During the Regression testing, executing all the test cases from existing test suite is not possible because that takes more time to test the modified software. This paper proposes new Hybrid approach that consists of modified Greedy approach for handling the test case selection and Genetic Algorithm uses effective parameter like Initial Population, Fitness Value, Test Case Combination, Test Case Crossover and Test Case Mutation for optimizing the tied test suite. By doing this, effective test cases are selected and minimized the tied test suite to reduce the cost of the testing process. Finally the result of proposed approach compared with conventional greedy approach and proved that our approach is more effective than other existing approach.

Teaching the entire software development life cycle

In a very real sense, so called soft skills are more important in software development than is good programming. For example, if the results of a project's requirements engineering efforts are po...

Resolving Ambiguities in Natural Language Software Requirements

Requirements Engineering is one of the most vital activities in the entire Software Development Life Cycle. The success of the software is largely dependent on how well the users' requirements have been understood and converted into appropriate functionalities in the software. Typically, the users convey their requirements in natural language statements that initially appear easy to state. However, being stated in natural language, the statement of requirements often tends to suffer from misinterpretations and imprecise inferences. As a result, the requirements specified thus, may lead to ambiguities in the software specifications. One can indeed find numerous approaches that deal with ensuring precise requirement specifications. Naturally, an obvious approach to deal with ambiguities in natural language software specifications is to eliminate ambiguities altogether i.e. to use formal specifications. However, the formal methods have been observed to be cost-effective largely for the development of mission-critical software. Due to the technical sophistication required, these are yet to be accepted in the mainstream. Hence, the other alternative is to let the ambiguities exist in the natural language requirements but deal with the same using proven techniques viz. using approaches based on machine learning, knowledge and ontology to resolve them. One can indeed find numerous automated and semi-automated tools to resolve specific types of natural language software requirement ambiguities. However, to the best of our knowledge there is no published literature that attempts to compare and contrast the prevalent approaches to deal with ambiguities in natural language software requirements. Hence, in this paper, we attempt to survey and analyze the prevalent approaches that attempt to resolve ambiguities in natural language software requirements. We focus on presenting a state-of-the-art survey of the currently available tools for ambiguity resolution. The objective of this paper is to disseminate, dissect and analyze the research work published in the area, identify metrics for a comparative evaluation and eventually do the same. At the end, we identify open research issues with an aim to spark new interests and developments in this field.

Textual Adventures: Writing and Game Development in the Undergraduate Classroom

Abstract Building on scholarship in video game studies, this article argues that rather than writing about games as textual artifacts or playing games to reveal what they can teach us about writing, we should design curricula that introduce students to all of the writing that supports a successful game. The broader claim is that good writing leads to good software. In this case the software in question just happens to be a video game. The software and information technology industries value skilled writers, and those involved with writing pedagogy should continue to explore new methods for preparing students for these opportunities. Building on existing narratological approaches to teaching games is recommended as a place to begin. This article documents a specific endeavor to teach writing through software and game development. The article demonstrates how students experience the entire software development life cycle and its many writing challenges while developing their own text-based adventure games from the ground up.

What Next? Advances in Software-Driven Industries

Software-driven industries are advancing in five dimensions: collaboration, comprehension, connectivity, cloud, and convergence. However, companies often can get stuck in an overly narrow technology focus. To avoid this, they should connect architecture and functionality, master the entire software development life cycle, strengthen globally distributed teams, and streamline development.

Revisiting Requirements Elicitation Techniques

The importance of Requirements Engineering (RE) has been well recognized by the research community in the last decade. There is no doubt to say that requirements phase is the foundation of the entire Software Development Life Cycle (SDLC) on which the entire software is built. With the proper management of various activities falling under requirements phase, a project can deliver the right solution within the time and budget. Requirement elicitation, requirement specification, and requirement validation are the important stages to assure the quality of requirement documentations. Out of these, elicitation is the first major activity, which requires proper attention by Requirement Engineers and other related stakeholders. Literature reveals various elicitation techniques, which can be used for the purpose depending upon the nature of project/s. In this paper, an attempt is made to cover all the major elicitation techniques along with their significant aspects at one place. Such a review would enable the concerned stakeholders to understand and select the most appropriate technique to be used for their project/s.

Software test effort estimation: a model based on cuckoo search

Test effort estimation is the process of predicting effort for testing the software. It has always been a fascinating area for software engineering researchers. “How long will it take to test the system?” is the most promising question in minds of testers before the testing process actually starts. Many factors such as the productivity of the test team, strategy chosen for testing, the size and complexity of the system, technical factors, and expected quality can affect test effort estimation. Testing requires a good amount of time and effort in the entire software development life cycle. Several researches have attempted to develop test effort estimation models but still it is not possible to achieve accurate forecasting. A new model based on a metaheuristic technique called, cuckoo search, for estimating the test effort is proposed in this paper. The proposed model is used to assign weights to the various factors involved based on past results, and, is then used for predicting the test effort for new projects of similar kind.

Tool building in formal methods

Tool building in formal methods

Software testing—testing across the entire software development lifecycle. By Gerald D Everett & Raymond McLeod Jr. Published by IEEE Press and Wiley Interscience, Hoboken, NJ, U.S.A. ISBN: 978‐0‐471‐79371‐7, 260 pages. Price $47.50

Software testing—testing across the entire software development lifecycle. By Gerald D Everett & Raymond McLeod Jr. Published by IEEE Press and Wiley Interscience, Hoboken, NJ, U.S.A. ISBN: 978‐0‐471‐79371‐7, 260 pages. Price $47.50

Improving Software Development through Three Stages

In three stages covering 12 years and 16 projects, a software development group worked on attaining visible schedule control and usable software design documentation. The first stage identified two major problems: unstable code and schedule delays. The group used code inspection to address the immediate issue of code construction. In the second stage, the group formulated and implemented a software development process that addressed the entire software development life cycle. The third stage improved that process. The major factor in process improvement was the group's willingness to identify its mistakes and problems.

Supporting scenario evolution

Scenarios have been shown to be very helpful in identifying and communicating requirements for computer-based systems (CBSs). However, they appear not to be applicable to the rest of the CBS development process. Making scenarios more useful for the entire software development lifecycle requires integrating scenarios to other representations used during CBS development. This integration is achieved with tracing technology. Having integrated scenarios into the entire software development lifecycle creates the necessity to maintain scenarios through the inevitable changes that they and other documents undergo and to subject them to configuration management. We have prototyped automated support for full-lifecycle scenario management and have applied it to some non-trivial systems.

High Assurance Software Testing In Business And DOD

This paper argues that software testing can be less thorough yet more efficient if applied in a well-managed, empirical manner across the entire Software Development Life Cycle (SDLC). To ensure su...

Body of knowledge for software quality measurement

Measuring quality is the key to developing high-quality software. The author describes two approaches that help to identify the body of knowledge software engineers need to achieve this goal. The first approach derives knowledge requirements from a set of issues identified during two standards efforts: the IEEE Std. 1061-1998 for a Software Quality Metrics Methodology and the American National Standard Recommended Practice for Software Reliability (ANSI/AIAA R-013-1992). The second approach ties these knowledge requirements to phases in the software development life cycle. Together, these approaches define a body of knowledge that shows software engineers why and when to measure quality. Focusing on the entire software development life cycle, rather than just the coding phase, gives software engineers the comprehensive knowledge they need to enhance software quality and supports early detection and resolution of quality problems. The integration of product and process measurements lets engineers assess the interactions between them throughout the life cycle. Software engineers can apply this body of knowledge as a guideline for incorporating quality measurement in their projects. Professional licensing and training programs will also find it useful.

Java and the shift to net-centric computing

Java is an object-oriented programming language with a syntax similar to C and C++, only simpler. Because Java is an interpreted language, the typical C or C++ compile-link-load-test-debug cycle is reduced. Java development environments actually let the entire software-development life cycle take place within a Web browser. The author discusses some basic and advanced features of Java, including garbage collection, multithreading and application programming interfaces.