Phases Of Software Development Research Articles

Model-based Security Engineering of SOA Systems Using Modified "UML-SOA-Sec"

In SOA environment, software systems are composed of services which are scattered across enterprises and architectures. Security play vital role during the design, development and operation of SOA application. However, analysis of today’s software development approaches reveals that the engineering of security into the system design is often neglected. Currently security is incorporated in SOA applications in an ad-hoc manner and integrated during the applications development phase or administration phase or it is out sourced. In practice security is not defined during the early phases of software development and left onto developers. Properly configuring security requirements in SOA applications is quite difficult for developers because they are not security experts; furthermore, SOA security is cross-domain and all required information is not available at downstream phases. This reveals the importance of adding security objectives in early development phases i.e. at design phase by the business process expert. However, a business process expert is unable to specify security objectives due to lake of security modelling elements in a general purpose modelling languages. As a result, he/she either ignores the security objectives in a business process model or indicates them in textual way. The post-hoc, low-level integration of security has a negative impact on resulting SOA applications. A Domain Specific Language named “UML-SOA-Sec” is proposed for the Model driven development of secure SOA systems based on the UML. Aim is to facilitate the business process expert in modelling the security requirements along the business process modelling. This security annotated business process model will facilitate the security expert in specifying the concrete security implementation. As a proof of work; proposed “UML-SOA-Sec” is applied to modelling of a typical business process of healthcare system.

Implementation of Persistence as an Aspect

Data base and its implantation through various means, always demand the security of data which is stored in it. From view point of security from earlier days the DBA stores the data at different levels and level is available to the concerned person only. The data with the highest level of security is also termed as persistence data. Some authors also consider the term persistence as proper means of storage and retrieval of data from the storage devices. During this storage and retrieval the overlapping of code for verification of user make it implementable as cross cutting concerns. In this paper we provide the inside scene for implementing persistence as an aspect so that it can be embedded with phases of software development and can be reused when needed.

A Domain-Specific Language for Modelling Security Objectives in a Business Process Models of SOA Applications

Business process modelling is very crucial for enterprises because it give an idea how the business would be operated in the real world and it is important for every stakeholder. SOA is one of the most popular architecture for building Web Information Systems. In current SOA system development practices, security is not defined at the early phases of software development and left on the developer. Properly configuring security requirements in SOA applications is quite difficult for developers because they are not security experts, furthermore SOA security is cross-domain and all required information are not available at downstream phases. The post-hoc, low-level integration of security has a negative impact on resulting SOA applications. Business process modelling is normally performed by the Business Process expert who is not a security expert. Furthermore current business process modelling languages like UML or BPMN do not support the specification of security requirements along the business process modelling. We have presented a DSL, to model the security requirements along the business process model. We are facilitating the Business Process expert to model the security in business process diagram. This security annotated business process model will facilitate the security expert in specifying concrete security implementation. As a proof of work the proposed DSL is applied to the modeling of a typical business process of “on-line student information system”.

Applying requirement based complexity for the estimation of software development and testing effort

The need of computing the software complexity in requirement analysis phase of software development life cycle (SDLC) would be an enormous benefit for estimating the required development and testing effort for yet to be developed software. Various research proposals are directed towards minimizing the cost of software. Also, a relationship between source code and difficulty in developing a source code are also attempted in order to estimate the complexity of the proposed software for cost estimation, man power build up, code and developer's evaluation. Therefore, this paper presents a systematic and integrated approach for the estimation of software development and testing effort on the basis of improved requirement based complexity (IRBC) of the proposed software. The IRBC measure serves as the basis for estimation of these software development activities to enable the developers and practitioners to predict the critical information about the software development intricacies. Efficient software development requires accurate estimates, since inappropriate estimates causes' trouble during implementation of software process. Hence, this paper presents a comprehensive approach, for the prediction of software development and testing effort using IRBC. For validation purpose, the proposed measures are categorically compared with various established and prevalent practices proposed in the past like code based, use case based, algorithmic model and function point based estimation measures. Finally, the results obtained, validates the claim, for the approaches discussed in this paper, for estimation of software development and testing effort, in the early phases of software development appears to be robust, comprehensive, early alarming and compares well with other measures proposed in the past. Hence, it is even more useful because the complexity, development and testing effort estimates are obtained at very early stage.

Defect Prevention Based on 5 Dimensions of Defect Origin

“Discovering the unexpected is more important than confirming the known. In software development, the “unexpected” one relates to defects. These defects when unattended would cause failure to the product and risk to the users. The increasing dependency of society on software and the crucial consequences that a failure can cause requires the need to find out the defects at the origin itself. Based on the lessons learnt from the earlier set of projects, a defect framework highlighting the 5 Dimensions (Ds) of defect origin is proposed in this work. The defect framework is based on analyzing the defects that had emerged from various stages of software development like Requirements, Design, Coding, Testing and Timeline (defects due to lack of time during development). This study is not limited to just identifying the origin of defects at various phases of software development but also finds out the reasons for such defects, and defect preventive (DP) measures are proposed for each type of defect. This work can help practitioners choose effective defect avoidance measures.

Synthesis and Refinement Check of Sequence Diagrams

SUMMARY During a software development phase where a product is progressively elaborated, it is difficult to guarantee that the refined product retains its original behaviors. In this paper, we propose a method to detect refinement errors in UML sequence diagrams using LTSA (Labeled Transition System Analyzer). The method integrates multiple sequence diagrams using hMSC (high-level Message Sequence Charts) into a sequence diagram. Then, the method translates the diagram into FSP representation, which is the input language of LTSA. The method also supports some combined fragment operators in the UML 2.0 specification. We applied the method to some examples of refined sequence diagrams and checked the correctness of refinement. As a result, we confirmed the method can detect

Test Case Generation For Concurrent Object-Oriented Systems Using Combinational Uml Models

Software testing is an important phase of software development to ensure the quality and reliability of the software. Due to some limitations of code based testing method, the researcher has been taken a new method to work upon UML model based testing. It is found that different UML model is having different coverage and capable of detecting different kinds of faults. Here we have taken combinational UML models to have better coverage and fault detection capability. Testing concurrent system is difficult task because due to concurrent interaction among the threads and the system results in test case explosion. In this paper we have presented an approach of generating test cases for concurrent systems using combinational UML models i.e. sequence diagram and activity diagram .Then a Sequence-Activity Graph (SAG) is constructed from these two diagrams. Then that graph is traversed to generate test cases which are able to minimize test case explosion.

Prioritizing Test Cases Using Business CriticalityTest Value

Software maintenance is an important and costly activity of the software development lifecycle. Regression testing is the process of validating modifications introduced in a system during software maintenance. It is very inefficient to re-execute every test case in regression testing for small changes. This issue of retesting of software systems can be handled using a good test case prioritization technique. A prioritization technique schedules the test cases for execution so that the test cases with higher priority executed before lower priority. The objective of test case prioritization is to detect fault as early as possible. Early fault detection can provide a faster feedback generating a scope for debuggers to carry out their task at an early stage. Model Based Prioritization has an edge over Code Based Prioritization techniques. The issue of dynamic changes that occur during the maintenance phase of software development can only be addressed by maintaining statistical data for system models, change models and fault models. In this paper we present a novel approach for test case prioritization by evaluating the Business Criticality Value (BCV) of the various functions present in the software using the statistical data. Then according to the business criticality value of various functions present in the change and fault model we prioritize the test cases are prioritized.

Incorporating Agile With mda Case Study: Online Polling System

Nowadays agile software development is used in greater extend but for small organizations only, whereas MDA is suitable for large organizations but yet not standardized. In this paper the pros and cons of Model Driven Architecture (MDA) and Extreme programming have been discussed. As both of them have some limitations and cannot be used in both large scale and small scale organizations a new architecture has been proposed. In this model it is tried to opt the advantages and important values to overcome the limitations of both the software development procedures. In support to the proposed architecture the implementation of it on Online Polling System has been discussed and all the phases of software development have been explained.

BioCreative III interactive task: an overview

BackgroundThe BioCreative challenge evaluation is a community-wide effort for evaluating text mining and information extraction systems applied to the biological domain. The biocurator community, as an active user of biomedical literature, provides a diverse and engaged end user group for text mining tools. Earlier BioCreative challenges involved many text mining teams in developing basic capabilities relevant to biological curation, but they did not address the issues of system usage, insertion into the workflow and adoption by curators. Thus in BioCreative III (BC-III), the InterActive Task (IAT) was introduced to address the utility and usability of text mining tools for real-life biocuration tasks. To support the aims of the IAT in BC-III, involvement of both developers and end users was solicited, and the development of a user interface to address the tasks interactively was requested.ResultsA User Advisory Group (UAG) actively participated in the IAT design and assessment. The task focused on gene normalization (identifying gene mentions in the article and linking these genes to standard database identifiers), gene ranking based on the overall importance of each gene mentioned in the article, and gene-oriented document retrieval (identifying full text papers relevant to a selected gene). Six systems participated and all processed and displayed the same set of articles. The articles were selected based on content known to be problematic for curation, such as ambiguity of gene names, coverage of multiple genes and species, or introduction of a new gene name. Members of the UAG curated three articles for training and assessment purposes, and each member was assigned a system to review. A questionnaire related to the interface usability and task performance (as measured by precision and recall) was answered after systems were used to curate articles. Although the limited number of articles analyzed and users involved in the IAT experiment precluded rigorous quantitative analysis of the results, a qualitative analysis provided valuable insight into some of the problems encountered by users when using the systems. The overall assessment indicates that the system usability features appealed to most users, but the system performance was suboptimal (mainly due to low accuracy in gene normalization). Some of the issues included failure of species identification and gene name ambiguity in the gene normalization task leading to an extensive list of gene identifiers to review, which, in some cases, did not contain the relevant genes. The document retrieval suffered from the same shortfalls. The UAG favored achieving high performance (measured by precision and recall), but strongly recommended the addition of features that facilitate the identification of correct gene and its identifier, such as contextual information to assist in disambiguation.DiscussionThe IAT was an informative exercise that advanced the dialog between curators and developers and increased the appreciation of challenges faced by each group. A major conclusion was that the intended users should be actively involved in every phase of software development, and this will be strongly encouraged in future tasks. The IAT Task provides the first steps toward the definition of metrics and functional requirements that are necessary for designing a formal evaluation of interactive curation systems in the BioCreative IV challenge.

Software fault prediction for object oriented systems

There always has been a demand to produce efficient and high quality software. There are various object oriented metrics that measure various properties of the software like coupling, cohesion, inheritance etc. which affect the software to a large extent. These metrics can be used in predicting important quality attributes such as fault proneness, maintainability, effort, productivity and reliability. Early prediction of fault proneness will help us to focus on testing resources and use them only on the classes which are predicted to be fault-prone. Thus, this will help in early phases of software development to give a measurement of quality assessment. This paper provides the review of the previous studies which are related to software metrics and the fault proneness. In other words, it reviews several journals and conference papers on software fault prediction. There is large number of software metrics proposed in the literature. Each study uses a different subset of these metrics and performs the analysis using different datasets. Also, the researchers have used different approaches such as Support vector machines, naive bayes network, random forest, artificial neural network, decision tree, logistic regression etc. Thus, this study focuses on the metrics used, dataset used and the evaluation or analysis method used by various authors. This review will be beneficial for the future studies as various researchers and practitioners can use it for comparative analysis.

Global software engineering and agile practices: a systematic review

SUMMARYAgile practices have received attention from industry as an alternative to plan‐driven software development approaches. Agile encourages, for example, small self‐organized collocated teams, whereas global software engineering (GSE) implies distribution across cultural, temporal, and geographical boundaries. Hence, combining them is a challenge. A systematic review was conducted to capture the status of combining agility with GSE. The results were limited to peer‐reviewed conference papers or journal articles, published between 1999 and 2009. The synthesis was made through classifying the papers into different categories (e.g. publication year, contribution type, research method). At the end, 81 papers were judged as primary for further analysis. The distribution of papers over the years indicated that GSE and Agile in combination has received more attention in the last 5 years. However, the majority of the existing research is industrial experience reports in which Agile practices were modified with respect to the context and situational requirements. The emergent need in this research area is suggested to be developing a framework that considers various factors from different perspectives when incorporating Agile in GSE. Practitioners may use it as a decision‐making basis in early phases of software development. Copyright © 2011 John Wiley & Sons, Ltd.

Using the Affect Grid to Measure Emotions in Software Requirements Engineering

Computer systems are designed and used by humans. And human being is characterized, among other things, by emotions. Giving this fact, the process of designing and developing computer systems is, like any other facet in our lives, driven by emotions. Requirements engineering is one of the main phases in software development. In Requirements engineering, several tasks include acceptance and negotiation activities in which the emotional factor represents a key role. This paper presents a study based on the application of affect grid by Russell in requirements engineering main stakeholders: developers and users. Results show that high arousal and low pleasure levels in the process are predictors of conflictive requirements.

Importance of Data Collection and Validation for Systematic Software Development Process

Systematic software development process involves estimation of size, effort, schedule and cost of a software project and analysis of critical factors affecting these estimates. In literature there are many methods for software estimation and categorization of critical factors. More than 50% of the projects undertaken have challenged the initially proposed estimates. Even if we consider updating estimates at various phases of software development, the percentage of challenged projects reduces marginally. The reason for such a situation is that the decisions are made on historical and collected data. Therefore, software data collection to a reasonable accuracy and its validation is important both for decision making and validating software development process. In this paper an effort is made to highlight the importance of software data collection. Collected data is utilized to validate effort estimation model formulated by the authors. Comparison of effort values obtained from popular estimation models is also made. The data collected has also helped in identifying the critical factors affecting the estimates.

임베디드 소프트웨어의 설계모델로부터 에너지 효율을 향상시키기 위한 태스크 도출

저전력을 소모하는 임베디드 시스템 개발의 중요성이 증대되고 있다. 저전력 소모의 시스템 개발은 하드웨어 측면에서 많이 연구되어 왔지만, 소프트웨어의 동작이 하드웨어 전력 소모를 유발하기 때문에 소프트웨어의 소모 전력을 분석하는 것 또한 중요한 이슈중의 하나이다. 본 논문에서는 임베디드 소프트웨어 개발 과정에서 작성되는 설계 모델을 이용하여 에너지 효율적인 태스크 도출 방법을 제시한다. 이를 위하여 먼저 태스크 분할 기준을 제시하고, 이를 이용한 UML 설계 모델의 분할 과정을 설명한다. 제안된 태스크 도출 방법은 성능과 함께 전력 소모에 많은 영향을 미치는 임베디드 소프트웨어 개발에 활용하여 선행적으로 에너지 소모량을 절감할 기회를 제공할 수 있다. The importance of low-power embedded system is being increased. The studies on low-power system have been performed in issues of hardware architecture and operating system. However because the behaviors of software control the working of hardware devices, the power analysis of software is one of critical issues in energy-efficient embedded system development. This paper proposes a technique to extract tasks from software design models with considering power consumption. We first define the criteria for task extraction, and then propose the way to separate out the task from UML 2.0 design models. Our technique can provide the chance to reduce the power consumption as well as to fulfill the performance requirement in the early phase of software development.

The Study of Resource Allocation among Software Development Phases: An Economics-Based Approach

This paper presents an economics-based approach for studying the problem of resource allocation among software development phases. Our approach is structured along two parallel axes: theoretical and empirical. We developed a general economic model for analyzing the allocation problem as a constrained profit maximization problem. The model, based on a novel concept of software production function, considers the effects of different allocations of development resources on output measures of the resulting software product. An empirical environment for evaluating and refining the model is presented, and a first exploratory study for characterizing the model's components and developers' resource allocation decisions is described. The findings illustrate how the model can be applied and validate its underlying assumptions and usability. Future quantitative empirical studies can refine and substantiate various aspects of the proposed model and ultimately improve the productivity of software development processes.

Software Security Requirements Gathering Instrument

Security breaches are largely caused by the vulnerable software. Since individuals and organizations mostly depend on softwares, it is important to produce in secured manner. The first step towards producing secured software is through gathering security requirements. This paper describes Software Security Requirements Gathering Instrument (SSRGI) that helps gather security requirements from the various stakeholders. This will guide the developers to gather security requirements along with the functional requirements and further incorporate security during other phases of software development. We subsequently present case studies that describe the integration of the SSRGI instrument with Software Requirements Specification (SRS) document as specified in standard IEEE 830-1998. Proposed SSRGI will support the software developers in gathering security requirements in detail during requirements gathering phase.

Fault Prediction Model by Fuzzy Profile Development of Reliability Relevant Software Metrics

This paper presents a fault prediction model using reliability relevant software metrics and fuzzy inference system. For this a new approach is discussed to develop fuzzy profile of software metrics which are more relevant for software fault prediction. The proposed model predicts the fault density at the end of each phase of software development using relevant software metrics. On the basis of fault density at the end of testing phase, total number of faults in the software is predicted. The model seems to useful for both software engineer as well as project manager to optimally allocate resources and achieve more reliable software within the time and cost constraints. To validate the prediction accuracy, the model results are validated using PROMISE Software Engineering Repository Data set.

Imperfect-Debugging SRGM with Software Module Testing and Resource Allocation Dependent Release Policy

Testing is one of the important phase in software development. Main Purpose of testing is to identify the number of errors present in the software. In the history of software development several testing techniques and methods are used in finding out the errors. Module testing is one of the sophisticated testing technique. Software release problem is the one of oldest of problem in which managers could find a time at which testing is be to stopped such that released software should have more quality. During the testing many resources are consumed; every manager’s intension is to find efficient method of allocating resources during software module testing such that it saves time and resource. In this paper we have combined the software release problem with resource allocation with software reliability growth model with imperfect-debugging phenomenon. Experiments are conducted on datasets. The results show our proposed model fits better than other. General Terms Software reliability, software testing, software release time, resource allocation

스토리보드 소프트웨어의 사용빈도 순위와 사용성

90년대 이후부터 스토리보드의 디지털화가 꾸준히 연구되어 오면서 많은 종류의 스토리보드 소프트웨어들이 탄생하게 되었다. 그러나 이러한 소프트웨어들이 기존의 방식에 비해 효율적으로 어떠한 차이점이 있는지에 대한 구체적인 데이터가 부족하여 85명의 실험대상자에게 사용빈도수에 따른 스토리보드 소프트웨어 5개를 선정하여 사용성을 분석해 본 결과 크게 2가지의 결과를 도출해 낼 수 있었다. 첫째로는 선정된 5개의 소프트웨어 모두 상호작용 표현기능이 누락되어 있어 이것의 개발방향을 제시 할 수 있었으며. 둘째로는 스토리보드 소프트웨어로 얻을 수 있는 가장 중요한 효과는 콘텐츠의 디지털화가 아닌 콘텐츠의 실시간 플레이를 통해 얻을 수 있는 정보 전달력에 있다는 것을 실험을 통해 알 수 있었다. 본 연구를 통하여 얻은 결과는 소프트웨어의 개발자에게 새로운 모델을 제시 할 수 있으며 사용자에게는 스토리보드 소프트웨어를 통해 얻을 수 있는 효과를 이해하는 데에 도움이 될 수 있기를 기대한다. Due to the trend of shift to digitalization of the storyboard in 1990's, many a number of storyboard related softwares were born. With this change of trends, however, there was an undeniable lack of tangible data showing the advantage of such digitalization of the storyboard using software technology over conventional methods of doing the same job. In this study, therefore, we have selected the top five storyboard software suits in terms of their frequency in use and a sample group of 85 people to give an analysis on their usability. The result of this analysis revealed two underlying tendencies regarding this issue. Firstly, all of the five softwares selected lacked interactive presentational features, suggesting the directives for the next phase of software development. Secondly, our experiments in this study showed that the most prominent benefit of using the softwares is the higher efficacy in delivering necessary information through real-time based replays, rather than the digitalization of the contents themselves. We expect that the findings of our study would serve as a new model for future software enhancement for the developers. And for the users of such softwares, too, the findings of this study is expected to help them understand what kind of benefits they can expect as they use these storyboard softwares.