Conventional Software Development Research Articles

Study of Learning Techniques for Effort Estimation in Object-Oriented Software Development

Software effort estimation (SEE) is helpful for project managers to decide the cost and effort needed to complete the project. The techniques used for estimating effort in conventional software development are not very useful for estimating effort in object-oriented projects because of their varying nature. The machine learning (ML) approaches are achieving greater recognition in SEE research because they can demonstrate the complex relationship between software effort and other attributes. So, there is a need for a systematic literature review (SLR) that can discuss the applicability of ML techniques for SEE in object-oriented projects, which is not available in the literature. This research aims to provide a specific review and analysis of various ML-based SEE works in the object-oriented software development (OOSD) paradigm based on different perspectives: type of learning technique used, type of performance measure used, performance level achieved, the dataset used, etc. Purposefully, we have chosen appropriate articles after applying selection and quality evaluation criteria. After investigation, we found that different ML techniques have been applied in these works, and their performance is better than the classical models. Hence, more efforts are needed to encourage the application of ML techniques for SEE in the OOSD paradigm. Also, most of the works have used small-sized datasets for effort estimation in OOSD, due to which their model's performance cannot be generalized. So, the researchers should collect more large-sized datasets working in line with the software organizations.

A Shift Left-Based Accessibility Model for Software Development Process Improvement

Accessibility modifications are required for individuals with situational, temporary, or permanent impairments to properly interact with web applications. Incorporating accessibility guidelines, such as the Web Content Accessibility Guidelines (WCAG), into software development, along with the software development life cycle and other paradigms, poses challenges. The linear progression of steps in a conventional software development process leads to the identification of problems at a later stage because testing is typically conducted toward the end. Limited attention to accessibility until the final development phase results in prolonged efforts, increased resource allocation, and higher expenses to address accessibility issues. Consequently, numerous software applications remain inaccessible to users with impairments. This study focuses on a Shift Left-based model to improve accessibility in the software development process. Employing the Shift Left a11y Model that emphasizes early integration for accessibility and coupling it with the Extreme Programming Development Life Cycle would enhance the integration of various testing practices and facilitate the development of software that is accessible to all users, including those with impairments. Keywords: Accessibility, accessible software, shift-left, model, methodology for accessible software

EXTREME PROGRAMMING VS SCRUM: A COMPARISON OF AGILE MODELS

For past couple of years agile software methods have been quite popular among the researchers. Agile models are known as light weight in contrast with conventional software development methodologies, due to their casual, versatile and adaptable style. Agile frameworks became heartily accepted by the software society in view of their concentration towards timely software conveyance, product quality and user satisfaction. For the fulfillment of requirements and needs of different software projects multiple agile frameworks are present to choose from. Out of these models Extreme Programming and Scrum are the most recognizable and generally utilized frameworks. This research contributes by investigating these two frameworks thoroughly. This paper conducts a comprehensive comparison between Scrum and Extreme programming to track down their commonalities, dissimilarities and investigate those attributes which complement each other.

A Secure Future for Open-Source Computational Science and Engineering

Open-source research software plays a central role in accelerating advances in science and engineering. Its increasing significance, however, incentivizes malicious actors to attack that software and compromise the systems on which it runs, undermining the free and open exchange of trustworthy research codes. In the world of conventional software development, there has been a shift towards integrating security as early as possible in the development process to guard against malicious activity. Given the potential risks at hand, developers of research software must consider how to do the same across the research software lifecycle. This editorial argues for the need to unite diverse forms of expertise in scientific computing and software security to address these challenges and outlines a roadmap for future work in this space.

Agile Software Development Techniques: A Survey

In this IT era, where there is a race of software development, it is necessary to introduce such types of software development techniques which will help the practitioners to deliver fast solutions. In the past, various traditional approaches were used for this purpose, but now agile techniques are getting more popular because conventional software development approaches are not efficient in managing the changing requirements. The agile software development process is one of the most emerging lightweight software development methodologies, which uses iterative and prototype development approaches to accommodate changes in software requirements. Final software products are delivered to the end-users in short iterations. One of the most noticeable drawbacks of agile methods is their limited courtesy to the structured and architectural design of the system. Hence this development approach will restrict small to medium design decisions only. In this paper, we have performed the analysis of different agile techniques, which will help the readers to understand their positive and negative points and select the most appropriate technique suited to their projects.

Managing non‐functional requirements in agile software development

Non-functional requirements define qualities of the software system that ensure effectiveness while embedding any constraints and restrictions on the design. A challenge rises with agile implementation in handling non-function requirements in regulated environments. Thus, a practitioner's perceptions of agile method tailoring are described in relation to inter-team boundaries and non-functional requirements. The research comprises 18 practitioner interviews from two multinational agile software development companies. Interviews were recorded, transcribed, and analysed using an approach informed by grounded theory and information flow models were used to compare and contrast interactions of processes. It was discovered that one of the case study companies managed non-functional requirements as artefacts in their agile methodology, while the other company reverts to conventional plan-based software development practices of documentation, timeline estimations, and safety critical requirements. This research creates a detailed comparison of these contrasting approaches. The main contribution of this study is a set of proposed recommendations to deal with non-functional requirements in a regulated environment using agile techniques. The introduction of two new artefacts, Documentation Work Item and Safety Critical Work Item, is recommended and it is accompanied with an illustrative example, to transform the handling of documentation and safety critical requirements in a more agile way.

Tailoring Agile-Based Software Development Processes

Software development process tailoring is a standard and regular practice of software development companies. Without realizing it as a regular and well-defined standard approach, companies perform it on an ad-hoc basis. Due to which, process tailoring could not be developed into a formal process and approach to managing software development, processes and projects. Software development process paradigm shift from conventional software development approaches to the agile methodologies left many companies struggling with the reusability of the existing processes and defining new processes from scratch. Limited work on process tailoring and lack of a formal approach, particularly for overwhelmingly used agile methodologies, affected the acknowledgment of this process. Addressing this limitation, present research work formulates a process tailoring framework to tailor agile-based software development processes. The proposed framework recommends tailoring three key processes of agile methodologies based on the project state considering the client’s perspective and requirements. The existing literature have been reviewed to develop a theoretical framework which is verified and validated through structured interviews and case study of real projects. The framework provides a formal and a structured approach to tailor agile-based processes and methodologies.

Personal Extreme Programming with MoSCoW Prioritization for Developing Library Information System

Software development projects require experience and knowledge of the developer or clients related to the system which will be developed. Unclear clients' needs potentially emerge many changes of needs during the process of development which can not be resolved by using conventional software development methodology. The implementation on the less significant requirements either from the clients or the system cause the development of the project took a long time. In this paper, we combine personal extreme programming (PXP) methodology with Moscow technique to overcome those problems. PXP is suitable to use in small to medium-sized projects if the clients do not know in detail about the needs in the development of application, application needed in relatively quick time, and the development phase is adjusted to use by a single programmer. Moscow technique was used for prioritizing requirements elicited in PXP methodology. Moscow is a method to determine priority needs based on cost, risk, and business value. This technique was applied during the planning phase of PXP to develop library application, thereby it reduced the time of project completion. The result was a library application suited the needs of clients to support business processes at Batu State Attorney's library.

Paradigm shift from conventional software quality models to web based quality models

Software quality is one of the pivotal aspects of the software development industry which ensures product compliance to the requirement specification and standards. Conventional software development was mostly related with building desktop applications. The past decade has seen a proliferation of a rchitectures, frameworks, and languages in software development. Software methodologies have shifted from building monolithic standalone applications to service-oriented, metric-driven, collaborative agile-based development of Web-based software. The work presented in this paper expounds the evident shift of quality models for conventional software to web-based software. It further suggests a π-model representation for quality criterion relationship interpretation for both types of software. The horizontal line of the π signifies the backbone of quality models with quality assessment parameters common to both kind of software whereas the two vertical pillars of the π depict the quality attributes specific to the software type. A comparison of some of the most prominent, free and open source web product performance tools is also presented.

Empirical Evaluation of Modified Agile Models

Empirical evaluation is one of the widely accepted validation method in the domain of software engineering which investigates the proposed technique via practical experience and reflects its benefits and limitations. Due to various advantages, agile models have been taking over the conventional software development methodologies since last two decades. However besides the benefits, various limitations have been noticed as well by the researchers and software industry in agile family. To achieve the maximum benefits it is vital to fix the limitations by customizing the development structure of agile models. This paper deals with the empirical analysis of modified agile models called Simplified Extreme Programing (SXP) and Simplified Feature Driven Development (SFDD), which are the modified forms of Extreme Programing (XP) and Feature Driven Development (FDD). SXP was presented to eliminate the issues of conventional XP such as, lack of documentation, poor architectural structure and less focus on design. SFDD was proposed to take care of reported issues in FDD such as explicit dependency on experienced staff, little or no guidance for requirement gathering, rigid nature to accommodate requirement changes and heavy development structure. This study evaluates SXP and SFDD through implementing client oriented projects and discusses the results with empirical analysis.

Empirical assessment of machine learning models for agile software development effort estimation using story points

In the present day developing houses, the procedures adopted during the development of software using agile methodologies are acknowledged as a better option than the procedures followed during conventional software development due to its innate characteristics such as iterative development, rapid delivery and reduced risk. Hence, it is desirable that the software development industries should have proper planning for estimating the effort required in agile software development. The existing techniques such as expert opinion, analogy and disaggregation are mostly observed to be ad hoc and in this manner inclined to be mistaken in a number of cases. One of the various approaches for calculating effort of agile projects in an empirical way is the story point approach (SPA). This paper presents a study on analysis of prediction accuracy of estimation process executed in order to improve it using SPA. Different machine learning techniques such as decision tree, stochastic gradient boosting and random forest are considered in order to assess prediction more qualitatively. A comparative analysis of these techniques with existing techniques is also presented and analyzed in order to critically examine their performance.

Large Scale Agile Adoption Model from Management Perspective

field of software engineering is growing rapidly due to increased change of customers' requirements and progress in technologies. Agile software development (ASD) have substituted the conventional Software development methodologies to enhance the software productivity through short increments and increased user satisfaction. The purpose of this research is to pinpoint the factors (success factors and risk factors) in adopting agile methods for large scale software development team from management perspective. We have adopted systematic literature review (SLR) as a research methodology for the identification of these factors. The expected outcomes of this research will provide input to our proposed model Large Scale Agile Adoption Model (LSAAM) from management perspective. The LSAAM intends to assist the agile experts in managing large team for software development. Keywordssoftware development, success factors, large development team, Systematic literature review.

HYBRID MODEL FOR SOFTWARE DEVELOPMENT

The methods used for conventional software development cannot be used directly for the development of web applications. Today most of the companies use scrum methodology for the development of web applications. But it seem to be difficult to use the scrum in large projects because of the change of requirement late in the project and also it is difficult apply scrum in a big team. This paper identifies and analyses the various changes required in the scrum methodology to make them applicable for the large projects and reduce the cost.

A Business Process view of Software: An effective measurement model to assess the operations readiness of software under construction

AbstractThis paper introduces the concept of a business process based measurement framework to assess completeness and correctness of an IT platform (software) for business operations readiness. Conventional software development methods do not provide the development status in a manner that reflects the business operations readiness perspective, especially when the development is outsourced. Conventional methods report in terms of the requirements developed and the number of test cases passed. In a typical operations production setup, the operations team executes the business process and hence is able to better appreciate the state of the software under construction in terms of business process. Business users validate the business process during the acceptance testing phase, but this is a post development completion activity. Consider the common scenario where a large software development project is close to its planned development end date (that is, pre user acceptance testing phase), and there is a delay as per schedule. Now, the business needs to take a call: Go Live / Not to Go Live with the business change, as planned. This decision is critical when the business change is “time‐to‐market” sensitive. To take such a call, the business needs to have a clear understanding of the level of readiness of the software from a business operations perspective; whereas the standard measures applied to report the completion status of a software development project is the number of requirements developed and the number of test cases passed. Such a report does not provide the business with a view of the operations readiness of the software. In this paper, the author has made an attempt to provide a mechanism by which the level of completion of the software can be represented using a business process view and that in turn can measure the relative business operations readiness of the software, at any given point in time. This view can further be used as a feedback mechanism to prepare and execute the revised production rollout strategy for the software.

A Lifecycle Model for Web-based Application Development: Incorporating Agile and Plan-driven Methodology

For conventional software development, generic software engineering lifecycle model has proven to be very important. Though, with the evolution of Web-based applications and internet, conventional software engineering models have limited support for developing Web-based applications. In recent years Web-based applications have become more complex and new technologies are emerging at a rapid pace. Therefore, the conventional software engineering lifecycle models need to be reformed in such a way that handling the change requirements and complexity of Web-based development becomes convenient for conventional developers. However, there is a lack of any generic process model available for Web-based applications. The paper identifies and analyzes various aspects of conventional and Web-based development and proposes a lifecycle model, which incorporates the aspects of agile and plan-driven development to develop a Web-based application successfully.

Integrated Framework for Enhancing Software Development Methodologies With Comparative Analysis

The delivery process of any IT organization depends on the effective software development methodologies. Along with conventional software development methodologies, corporates are also found to adopt various quality standards in order to enhance their development methodologies. Although there were substantial researches work carried out in past, majority of the study discusses about the theoretical implementation of quality standards. Due to various intermittent impediments, e.g., requirement volatility, skill gap, schedule slippage, etc., the standard quality models are very often violated in real time environment leading to degradation in development methodologies. Hence, this manuscript discusses an integrated framework using Scrum, Lean Six Sigma, and Agile which has been formulated on the basis on existing flaws in software development methodologies and propose some of the potential features to enhance it.

A pluggable middleware architecture for developing context-aware mobile applications

The proliferation of powerful smartphone devices provides a great opportunity for context-aware mobile applications becoming mainstream. However, we argue that conventional software development tec...

EXRUP: A Hybrid Software Development Model for Small to Medium Scale Projects

The conventional and agile software development process models are proposed and used nowadays in software industry to meet emergent requirements of the customers. Conventional software development models such as Waterfall, V model and RUP have been predominant in industry until mid 1990s, but these models are mainly focused on extensive planning, heavy documentation and team expertise which suit only to medium and large scale projects. The Rational Unified Process is one of the widely used conventional models. Agile process models got attention of the software industry in last decade due to limitations of conventional models such as slow adaptation to rapidly changing business requirements and they overcome problems of schedule and cost. Extreme Programming is one of the most useful agile methods that provide best engineering practices for a good quality product at small scale. XP follows the iterative and incremental approach, but its key focus is on programming, and reusability becomes arduous. In this paper, we present characteristics, strengths, and weaknesses of RUP and XP process models, and propose a new hybrid software development model eXRUP (eXtreme Programming and Rational Unified Process), which integrates the strengths of RUP and XP while suppressing their weaknesses. The proposed process model is validated through a controlled case study.

Validating the Applicability of Agile Requirement Generation Model

We all know that agile methodology for software development is an alternative to waterfall methodology for software development. In today’s scenario, agile methods have caught the attention of software engineers worldwide. The reasons of this popularity are its iterative nature, quick delivery of software, face to face communication, less need of lengthy documentation etc. Agile methods focus on accommodating change even late in the development lifecycle. Though agile method are successfully applied on small softwares (whose development periods are less than 1-2 years), the main issue comes when someone want to apply agile methodology on large systems (development period greater than 2 years). One of the most important issues in the development of larger scale complex systems is accommodating changes to requirements. Someone proposed a soft-structured framework which combines the principles of agile and conventional software development that solves the issue of rapidly changing requirements for larger scale systems. The framework consists of two parts. First one is a soft structured requirements gathering approach that reflects the agile philosophy i.e. the Agile Requirements Generation Model and second one is a tailored development process that can be applied to either small or larger scale systems .The main work is to validate the applicability of the Agile RGM. So this paper validates the applicability of agile requirement generation model with the help of a project.

A New SDLC Framework with Autonomic Computing Elements

The autonomic complex nervous system of human has ability to manage itself. It adapts changes in its environment and manages by self-healing, self-protection and selfoptimization. This gave a robust idea to manage current complex engineering systems and reduce big efforts in maintenance in terms of cost and time of technically skilled human resource. This paper is providing a concept of developing an autonomic manager simultaneously with the developments of its particular system or software, via injecting the autonomic elements into conventional software development life cycle (SDLC) and hence it will become secure SDLC or autonomic SDLC framework.