Search

Iterative software development has become widely practiced in industry. Since modern software projects require fast, incremental delivery for every iteration of software development, it is essential to monitor the execution of an iteration, and foresee a capability to deliver quality products as the iteration progresses. This paper presents a novel, data-driven approach to providing automated support for project managers and other decision makers in predicting delivery capability for an ongoing iteration. Our approach leverages a history of project iterations and associated issues, and in particular, we extract characteristics of previous iterations and their issues in the form of features. In addition, our approach characterizes an iteration using a novel combination of techniques including feature aggregation statistics, automatic feature learning using the Bag-of-Words approach, and graph-based complexity measures. An extensive evaluation of the technique on five large open source projects demonstrates that our predictive models outperform three common baseline methods in Normalized Mean Absolute Error and are highly accurate in predicting the outcome of an ongoing iteration.

The new IEEE 11073 service-oriented device connectivity (SDC) standard proposals for networked point-of-care and surgical devices constitutes the basis for improved interoperability due to its independence of vendors. To accelerate the distribution of the standard a reference implementation is indispensable. However, the implementation of such a framework has to overcome several non-trivial challenges. First, the high level of complexity of the underlying standard must be reflected in the software design. An efficient implementation has to consider the limited resources of the underlying hardware. Moreover, the frameworks purpose of realizing a distributed system demands a high degree of reliability of the framework itself and its internal mechanisms. Additionally, a framework must provide an easy-to-use and fail-safe application programming interface (API). In this work, we address these challenges by discussing suitable software engineering principles and practical coding guidelines. A descriptive model is developed that identifies key strategies. General feasibility is shown by outlining environments in which our implementation has been utilized.

Many techniques have been proposed to automatically recover software architectures from software implementations. A thorough comparison among the recovery techniques is needed to understand their effectiveness and applicability. This study improves on previous studies in two ways. First, we study the impact of leveraging accurate symbol dependencies on the accuracy of architecture recovery techniques. In addition, we evaluate other factors of the input dependencies such as the level of granularity and the dynamic-bindings graph construction. Second, we recovered the architecture of a large system, Chromium, that was not available previously. Obtaining the ground-truth architecture of Chromium involved two years of collaboration with its developers. As part of this work, we developed a new submodule-based technique to recover preliminary versions of ground-truth architectures. The results of our evaluation of nine architecture recovery techniques and their variants suggest that (1) using accurate symbol dependencies has a major influence on recovery quality, and (2) more accurate recovery techniques are needed. Our results show that some of the studied architecture recovery techniques scale to very large systems, whereas others do not.

In software engineering, a scenario describes an anticipated usage of a software system. As scenarios are useful to understand the requirements and functionalities of a software system, the scenario-based analysis is widely used in various tasks, especially in the design stage of software architectures. Although researchers have proposed various scenario-based approaches to analyse software architecture, there are still limitations in this research field, and a key limitation is that scenarios are typically not formally defined and thus may contain ambiguities. As these ambiguities may lead to defects, it is desirable to reduce them as many as possible. In order to reduce ambiguity in scenario-based software architecture analysis, this paper introduces a creative computing approach to scenario-based software requirements analysis. Our work expands this idea in three directions. Firstly, we extend an architecture description language (ADL)-based language–Breeze/ADL to model the software architecture. Secondly, we use a creative rule–combinational rule (CR) to combine the vector clock algorithm for reducing the ambiguities in modelling scenarios. Then, another creative rule – transformational rule (TR) is employed to help to transform our Breeze/ADL model to a popular model – unified modelling language (UML) model. We implement our approach as a plugin of Breeze, and illustrate a running example of modelling a poetry to music system in our case study. Our results show the proposed creative approach is able to reduce ambiguities of the software architecture in practice.

The subjectivity that underlies the notion of quality does not allow the design and development of a universally accepted mechanism for software quality assessment. This is why contemporary research is now focused on seeking mechanisms able to produce software quality models that can be easily adjusted to custom user needs. In this context, we introduce QATCH, an integrated framework that applies static analysis to benchmark repositories in order to generate software quality models tailored to stakeholder specifications. Fuzzy multi-criteria decision-making is employed in order to model the uncertainty imposed by experts’ judgments. These judgments can be expressed into linguistic values, which makes the process more intuitive. Furthermore, a robust software quality model, the base model, is generated by the system, which is used in the experiments for QATCH system verification. The paper provides an extensive analysis of QATCH and thoroughly discusses its validity and added value in the field of software quality through a number of individual experiments.

The practical worth of models of technical processes depends on their accuracy, that is, the difference between model outputs and real measurements. For minimizing these differences, process identification methods are used. In this article, coordination software for process identification is presented which has the unique feature that it allows the integration of models that have been created with external tools, for example, Matlab or Python scripts. There is no need to transform the models into another type of software format to use the common identification coordinator. The concept of the software is described and two examples for the coupling with external simulation software are given. Additionally, this article contains a detailed case study of the parameter identification of two models using that identification coordination software. This highlights the benefit of the new coordination software regarding similar work flow for different model types. The modeled physical subject is the thermal behavior of an actuator strut.

Numerical instability is a well-known problem that may cause serious runtime failures. This paper discusses the reason of instability in software development process, and presents a toolchain that not only detects the potential instability in software, but also diagnoses the reason for such instability. We classify the reason of instability into two categories. When it is introduced by software requirements, we call the instability caused by problem . In this case, it cannot be avoided by improving software development, but requires inspecting the requirements, especially the underlying mathematical properties. Otherwise, we call the instability caused by practice . We design our toolchain as four loosely-coupled tools, which combine stochastic arithmetic with infinite-precision testing. Each tool in our toolchain can be configured with different strategies according to the properties of the analyzed software. We evaluate our toolchain on subjects from literature. The results show that it effectively detects and separates the instabilities caused by problems from others. We also conduct an evaluation on the latest version of GNU Scientific Library, and the toolchain finds a few real bugs in the well-maintained and widely deployed numerical library. With the help of our toolchain, we report the details and fixing advices to the GSL buglist.

International audience; Software Product Line Engineering (SPLE) aims at applying a pre-planned systematic reuse of large-grained software artifacts to increase the software productivity and reduce the development cost. The idea of SPLE is to analyze the business domain of a family of products to identify the common and the variable parts between the products. However, it is common for companies to develop, in an ad-hoc manner (e.g. clone and own), a set of products that share common services and differ in terms of others. Thus, many contributions are proposed to re-engineer existing product variants to a software product line. Nevertheless, these contributions are mostly focused on managing the variability at the requirement level. Few contributions address the variability at the architectural level despite its major importance. Starting from this observation, we propose an approach to reverse engineer the architecture of a set of product variants. Our goal is to identify variability and dependencies among architectural-element variants. Our work relies on formal concept analysis to analyze the variability. To validate the proposed approach, we experimented on two families of open-source product variants; Mobile Media and Health Watcher. %The results show that our approach is able to identify the architectural variability and the dependencies.

Context: Software Engineering is a discipline that has been shaped by over 50 years of practice. Many have argued that its theoretical basis has been slow to develop and that, in fact, a substantial theory of Software Engineering is still lacking.Objective: We propose a design theory for Software Engineering as a contribution to the debate. Having done this, we extend it to a design theory for socio-technical systems.Method: We elaborate our theory based on Gregors influential meta-theoretical exploration of the structural nature of a theory in the discipline of Information Systems, with particular attention to ontological and epistemological arguments.Results: We argue how, from an ontological perspective, our theory embodies a view of Software Engineering as the practice of framing, representing and transforming Software Engineering problems. As such, theory statements concern the characterisation of individual problems and how problems relate and transform to other problems as part of an iterative, potentially backtracking, problem solving process, accounting for the way Software Engineering transforms the physical world to meet a recognised need. From an epistemological perspective, we argue how the theory has developed through research cycles including both theory-then-(empirical-)research and (empirical-)research-then-theory strategies spanning over a decade; both theoretical statements and related empirical evidence are included.Conclusion: The resulting theory provides descriptions and explanations for many phenomena observed in Software Engineering and in the combination of software with other technologies, and embodies analytic, explanatory and predictive properties. There are however acknowledged limitations and current research to overcome them is outlined.

The definition of multiple visual strategies (MVS).The benefits of combination MVS for software evolution analysis.Experimental evaluation that supports the benefits of this combination.Combined visualization strategies perform better in terms of correctness and analysis time. Software engineers need to comprehend large amounts of data to maintain software. Software Visualization is an area that helps users to analyze software through the use of visual resources. It can be effectively used to understand the large amount of data produced during software evolution. A key challenge in the area is to create strategies to consistently visualize the many software attributes, modules and versions produced during its lifecycle. Most of the current visualization strategies seek to present data as a whole, including all available versions of the software in one visual scene. The area lacks strategies visualizing software in detail through the analysis of the evolution of specific software modules. Both strategies are useful, and should be selected according to the task at hand. This work focuses on combining software evolution visualization strategies, experimentally validating the benefits of the approach. Its goal was to build empirical evidence on the use of the combined multiple strategies for software evolution comprehension. It presents an experimental study that exploits the benefits of combining multiple visual strategies of software evolution analysis. The results show that combined visualization strategies perform better in terms of correctness and analysis time.

A Software Product Line (SPL) is defined as a set of software systems that share a common and managed set of features satisfying specific needs of a particular market segment or domain [1]. The SPL offers a number of common artifacts for building products, including mandatory and variable elements. SPL approaches have been adopted by many software companies1 to ease reuse and reduce time and production costs. A feature represents a functionality that is visible to the user and can be designed as a variability, which represents a variable functionality that may or may not be present in a product. On the other hand, mandatory features are common to all SPL products. To facilitate feature management, most SPL methodologies use the Feature Model (FM) [2] to represent all the SPL variabilities and commonalities.

This work describes the design, development and evaluation of a software Prototype, named ArchReco, an educational tool that employs two types of Context-aware Recommendations of Design Patterns, to support users (CS students or professionals) who want to improve their design skills when it comes to training for High Level Software models. The tool’s underlying algorithms take advantage of Semantic Web technologies, and the usage of Content based analysis for the computation of non-personalized recommendations for Design Patterns. The recommendations’ objective is to support users in functions such as finding the most suitable Design Pattern to use according to the working context, learn the meaning, objectives and usages of each Design Pattern. The current work presents the Semantic Modeling of the Software Design process through the definition of the context that defines the Software Design process and in particular the representation of the Design Patterns as Ontology model, the implemented Context Aware Recommendation Algorithms and the evaluation results extracted from a user based testing for the ArchReco prototype.

Software evolution has been a necessary part of the software development, while software architecture evolution is an important issue of software evolution. Software architecture evolution is generally realized through some evolution operations such as adding components or connectors, removing components or connectors. However, when some evolution operations are applied to the same software architecture in parallel, they sometimes make conflicting modifications, which will hinder the correctness of software architecture evolution. Although different approaches have been proposed to describe and analyze software architecture evolution, little work has been made to address evolution conflicts of software architectures. Focusing on parallel evolution conflicts of software architectures, firstly the paper establishes definitions and characterizations of parallel evolution conflicts of software architectures based on hypergraph morphisms and set theories, and describes parallel evolution conflicts of software architectures through these definitions and characterizations. Secondly the paper constructs the critical pair definition of parallel evolution conflicts of software architectures based on hypergraphs and hypergraph morphisms, analyzes the completeness of the critical pair, designs and optimizes an algorithm to detect efficiently parallel evolution conflicts of software architectures using the critical pair. Finally, a tool support is used to evaluate the effectiveness of the proposed method.

Errors in safety-critical software can have disastrous consequences. However, tools exist that developers can use to thoroughly analyze software subsystems for critical safety properties.

Software Cybernetics is adopted by our method to improve reliability of software.A nested control system is established to manage the process of verification.A model is built from requirements to formalize expected behaviors of software.Internal relationships of program are abstracted gradually to construct a model.The feedback is represented by a form of intermediate code. Software cybernetics aims at improving the reliability of software by introducing the control theory into software engineering domain systematically. A key issue in software verification is to improve the reliability of software by inspecting whether the software can achieve its expected behaviors. In this paper, the thought of software cybernetics is applied in the process of verification to address this issue and a nested control system is established. The proposed method verifies functional requirements in a dynamic environment with constantly changing user requirements, in which the program serves as a controlled object, and the verification strategy determined by software behavioral model (SBM) serves as a controller. The main contribution of this paper includes: (1) SBM is established in software design phase, and a concern-based construction approach is proposed, which starts from obtaining the software expected functionality extracted from a requirement text; (2) Program abstract-relationship model (PARM) is constructed basing on a process of gradual abstract to be a controlled object; (3) Feedback in a form of intermediate code is generated in the process of verification. The proposed method is validated by our case study.

Software Engineering is a discipline that provides a systematic approach to develop software in a cost-effective manner. Successful software development is challenged by various challenges, such as varying situational contexts, conformity with standards, changing requirements, optimism of schedule, schedule pressure, software complexity, and software invisibility. Varying situational contexts are the changed circumstances that are resulted due to varying situational factors. These situational factors are the root cause of varying situations, which need to be discovered in detail. If these situational factors are left unattended, they can cause software failures. Software standards can help to deal with software failures. In this paper, we have reviewed various software engineering standards from the Institute of Electrical and Electronics Engineers Standard Association. These software engineering standards were investigated for the factors and sub-factors that can lead to varying situations among software development team members. As a result we found 12 factors grouped with 52 sub-factors that can lead to varying situations among software development team members. These resulted factors and sub-factors can act as a source for varying situations among team members. Unattended identified situational factors can lead to software failures. This paper provides a guideline for the practitioners to consider these factors and sub-factors while performing software development in order to have a successful software development.

Even in the eighties, the need of managing software evolution has been detected as one of the most complex aspects of the software lifecycle. In this context, software architecture has been highlighted as an integral element of the software evolution process. However, no matter how much effort is put into the architecture, it must eventually be translated into source code. The potential misalignment between architecture and code can lead to failures in the evolution process in terms of economic impacts, failed expectations, and so on. In this article we report on a design science research study that we pursued to answer three research questions. First, we have studied whether and in how far it is possible to design an approach that both enforces the integration between software architecture and source code to avoid architectural erosion and architectural drift and, at the same time, provides automatic guidance to developers to carry out the required change tasks in each evolution steps. Second, we have studied whether this approach may be applied in realistic (open source) cases. Finally, we have analysed whether it is realizable at acceptable costs (in terms of development effort) in comparison to the overall development efforts roughly spent on the evolution of the projects in focus.

A look at the IEEE Software history website illustrates the practical value of historical data and offers a glimpse into the magazine's future.

Software architectural decisions have a significant impact on the software development process as well as on the quality of developed software systems. In this paper, the technique that allows selecting the optimal software architecture among several alternatives is proposed. This selection technique is reduced to the criteria importance theory for decision-making problems with a hierarchical criterion structure. For applying it, we need to pick up a set of metrics that assess the characteristics of the software architecture. Next, we need to determine metrics scale and create the hierarchical criterion structure with all the relations between software metric groups. The results allow us making conclusions about usefulness of the proposed technique during architecture design phase for software systems.

Software effort estimation is the process of calculating the effort required to develop a software product based on the input parameters that are usually partial in nature. It is an important task but the most difficult and complicated step in the software product development. Estimation requires detailed information about project scope, process requirements and resources available. Inaccurate estimation leads to financial loss and delay in the projects. Due to the intangible nature of software, most of the software estimation process is unreliable. But there is a strong relationship between effort estimation and project management activities. Various methodologies have been employed to improve the procedure of software estimation. This paper reviews journal articles on software development to get the direction in the future estimation research. Several methods for software effort estimation are discussed in this paper, including the data sets widely used and metrics used for evaluation. The use of evolutionary computational tools in the estimation is dealt with in detail. A new model for estimation using differential evolution algorithm called DEAPS is proposed and its advantages are discussed.

Display Omitted The extraction of software features from Software Requirement Specifications (SRS) is viable only to practitioners who have the access.Online reviews for software products can be used as input for features extraction to assist requirements reuse.Techniques from unsupervised learning and Natural Language Processing is employed as a propose solutions to Requirements Reuse problem.The approach obtained a precision of 87% (62% average) and a recall of 86% (82% average), when evaluated against the truth data set created manually. Sets of common features are essential assets to be reused in fulfilling specific needs in software product line methodology. In Requirements Reuse (RR), the extraction of software features from Software Requirement Specifications (SRS) is viable only to practitioners who have access to these software artefacts. Due to organisational privacy, SRS are always kept confidential and not easily available to the public. As alternatives, researchers opted to use the publicly available software descriptions such as product brochures and online software descriptions to identify potential software features to initiate the RR process. The aim of this paper is to propose a semi-automated approach, known as Feature Extraction for Reuse of Natural Language requirements (FENL), to extract phrases that can represent software features from software reviews in the absence of SRS as a way to initiate the RR process. FENL is composed of four stages, which depend on keyword occurrences from several combinations of nouns, verbs, and/or adjectives. In the experiment conducted, phrases that could reflect software features, which reside within online software reviews were extracted by utilising the techniques from information retrieval (IR) area. As a way to demonstrate the feature groupings phase, a semi-automated approach to group the extracted features were then conducted with the assistance of a modified word overlap algorithm. As for the evaluation, the proposed extraction approach is evaluated through experiments against the truth data set created manually. The performance results obtained from the feature extraction phase indicates that the proposed approach performed comparably with related works in terms of recall, precision, and F-Measure.

In this paper we draw on our experience in the automotive industry to portray the clear need for proper documentation of Simulink models when they describe the implementations of embedded systems. We effectively discredit the “model is documentation” motto that has been hounding the model-based paradigm of software development. The state of the art of documentation of Simulink designs of embedded systems, both in academia and industrial practice, is reviewed. We posit that lack of proper documentation is costing industry dearly, and propose that a significant change in development culture is needed to properly position documentation within the software development process. Further, we discuss what is required to foster such a culture.

Interviews with European and US software architects show not only a diverse practice of architecting but also the architect's transformation from primary decision maker to coordinator, advisor, and knowledge manager.

Software architecture design is an important step of software development. Currently, there are various design methods available and each is focusing on certain perspective of architecture design. Especially, quality-based methods have received a lot of attentions and have been well developed for single system architecture design. However, the use of quality-based design methods is limited in software product line (SPL) because of the complexity and variabilities existing in SPL architecture. With the increasing attention to software safety, improving software safety has already become a more important issue, especially for safety-critical systems. This study aims at surveying existing research on Software Product Line Architecture (SPLA) design based on quality attributes, and to give an overview of the intersection of the areas of software product line architecture design and Safety Driven Design in order to classifying existing work, and discover open issues for further research. Also this study investigates safety analysis at the architectural level, and Safety-based Software Product Line Architecture Design (SSPLAD) approaches. Safety-driven software product line architecture design seems to be a ''discussion" topic. The study shows that there are a large number of SPLA design methods. However, the use of safety-based design methods is limited in software product lines (SPL) due to the variability property that can potentially result in a large number of possible systems and because of the complexity existing in safety attribute itself.

Recently, software quality issues have emerged to be recognized as a fundamental point as we actualize an extensive growth of organizations involved in software industries. Still, these organizations cannot ensure the quality of their products; therefore abandoning customers in uncertainties. Software certification is the branch of quality by means that quality requires to be measured prior to certification admitting process. However, creating an official certification model is difficult due to the deficiency of data in the domain of software engineering. This research participates in solving the problem of assessing software quality by introducing a model that handles a fuzzy inference engine to mix both of the processes-driven and application-driven quality assurance procedures. The fundamental purpose of the suggested model is to enhance the compactness and the interpretability of the system's fuzzy rules via engaging an ant colony optimization algorithm (ACO), which attempts to discover a good rule description by a set of compound rules initially represented with traditional single rules. The proposed model is a fitting one that can be seen as practicing certification models that have already been created from software quality domain data and modifying them to a context-specific data. The model has been tested by a case study and the results have confirmed feasibility and practicality of the model in a real environment.

This paper proposes a framework for the development of sensor node software for various operating systems in a sensor network environment. The proposed development framework consists of attributes, code templates and development support tool. Sensor node software is developed, based on the framework through four steps —sensor network modeling, PIM design, PSM design and code generation. Accordingly, this paper presents the methods for attributes design, code templates design, PIM-to-PSM mapping, and source code generation. Through the proposed technique, reusability of sensor network software will be increased since models, attributes and code templates can be reused for various operating systems through the framework. Productivity of software development will be increased, because software design is easily performed using attributes and software codes for all nodes in the sensor network can be generated at once from a model. Also, expandability of sensor network software will be increased, since new functions of existing operating systems or new operating systems can be added through the framework and sensor network software can be rebuilt by applying the added functions or operating systems.

Architectural decisions have a significant impact on the development process as well as on the quality of applied systems. On the other hand, it would be desirable to rely on mature solutions and proven experience when making such decisions. Partially this problem could be solved with the use of architectural patterns. Such solution for the same task can be implemented using different sets of patterns. As a result, there is a problem of choosing and evaluating the software architecture that is build using a number of patterns and that meets the system requirements. In this paper, the technique that allows selecting the optimal software architecture for applied software is proposed. This selection technique is reduced to the criteria importance theory problem. For applying it, we need to pick up a set of metrics that assess the characteristics of the software architecture. Next, we need to determine metrics scale and information about their importance. The results allow us making conclusions about usefulness of the proposed technique during architecture design phase for applied software.

Information technology of information system software architecture structural synthesis is proposed. It is used for evolutionary models of the software lifecycle, which provides configuration and formation of software to control the realization and recovery of computing processes in parallel and distributed computing resources structures. The technology is applied in the framework of the software requirements analysis, design of architecture, design and integration of software. Method of combining vertices for multilevel graph model of software architecture and automata-based method of checking performance limitations to software are based on the advanced graph model of software architecture. These methods are proposed in the framework of information technology and allow forming a rational structure of the program, as well as checking for compliance with the functional and non-functional requirements of the end user. The essence of proposed information technology is in displaying of the customer's requirements in the current version of the graph model of program complex structure and providing a reconfiguration of the system modules. This process is based on the analysis and processing of the graph model, software module specifications, formation of software structure in accordance with the graph model, software verification and its compilation.

Purpose The purpose of this paper is to propose a software engineering procedure for real-time software development and verification of an autonomous underwater robotic system. High performance and robust software are one of the requirements of autonomous systems design. A simple error in the software can easily lead to a catastrophic failure in a complex system. Then, a systematic procedure is presented for this purpose. Design/methodology/approach This paper utilizes software engineering tools and hardware-inthe-loop (HIL) simulations for real-time system design of an autonomous underwater robot. Findings In this paper, the architecture of the system is extracted. Then, using software engineering techniques a suitable structure for control software is presented. Considering the desirable targets of the robot, suitable algorithms and functions are developed. After the development stage, proving the real-time performance of the software is disclosed. Originality/value A suitable approach for analyzing the real-time performance is presented. This approach is implemented using HIL simulations. The developed structure is applicable to other autonomous systems.

The features and basic functionality of the MVTU software package are considered. The software is intended for the research and design of a wide range of systems described by differential, algebraic, and difference equations. Examples of the solutions of the research and applied problems are given.

Efficacy of hyper-heuristic approach for module clustering was studied.Hyper-heuristic approach is effective in identifying "high quality" clusters.Hyper-heuristic approach is "fast" enough to reach out to the optimum.User-friendly framework for software module clustering is presented. In the software maintenance phase of software development life cycle, one of the main concerns of software engineers is to group the modules into clusters with maximum cohesion and minimum coupling.To analyze the efficacy of Multi-objective Hyper-heuristic Evolutionary Algorithm (MHypEA) in solving real-world clustering problems and to compare the results with the reported results in the literature for single as well as multi-objective formulations of the problem and also to present a CASE tool that assists software engineers in software module clustering process.The paper reports on empirical evaluation of the performance of MHypEA with the reported results in the literature. The comparison is mainly based on two factors - quality of the obtained solutions and the computational effort.On all the attempted problems, MHypEA reported good results in comparison to all the studies that were reported on multi-objective formulation of the problem, with a computational effort of nearly one-twentieth of the computational effort required by the other multi-objective algorithms.The hyper-heuristic approach is able to produce high quality clustered systems with less computational effort.

Software engineering (SE) is an area with a wide range of concepts and knowledge. Such diversity of topics, requires the application of different teaching and learning techniques for an effective education. Serious Games is one of such techniques, yet its design tends to be complex, currently lacking a map of game design standards that comply with SE education requirements. This paper presents a process to identify the game design patterns that can be effective for teaching software engineering, specifically the software project management topic. Firstly, it begins by identifying the relationship between game design patterns and teaching and learning functions based on literature review. Secondly, it filters which of those teaching and learning functions is most relevant to software project management education, according to SE education specialists. Finally, it validates the relationship between game design patterns and software project management education through an empirical study conducted with master students. The results can be used as a basis for designing and developing serious games for teaching software project management.

We present a systematic approach for eliciting, analyzing, and modeling requirements.It combines established methods from social sciences and software engineering.It prevents the three issues discussed in the paper: unawareness, early commitment, and ungroundedness. Requirements engineering produces specifications of the needs or conditions to meet for a software product. These specifications may be vague and ungrounded, i.e. the relation of the requirements to the observations they are derived from may be unclear or not documented. Furthermore, stakeholders may be influenced by solutions of existing software without knowing if these actually suit the software to be developed.To cope with the above issues, it is important to understand the complete task, before designing a software system to support the task. Thus, we developed a method called Grounded Requirements Engineering (GRE) that leverages the Grounded Theory method to observe and analyze processes and user activities in the real world.GRE is an iterative process consisting of two steps. First, Grounded Theory methods are used to analyze user experiments or interviews. Second, the resulting abstract descriptions of the user behavior are transferred into use cases. GRE produces comprehensible and grounded requirements for the software system to be built, i.e. the requirements are traceable back to their origins.In this paper, we provide an elaborate description of the GRE method and illustrate it by applying it to derive requirements for an interactive software tool for model merging. The development of this tool both served as a basis for the design of GRE as well as to test it.

We all want to be associated with long lasting ideas; as originators, or at least, expositors. For a tyro researcher or a seasoned veteran, knowing how long an idea will remain interesting in the community is critical in choosing and pursuing research threads. In the physical sciences, the notion of half-life is often evoked to quantify decaying intensity. In this paper, we study a corpus of 19,000+ papers written by 21,000+ authors across 16 software engineering publication venues from 1975 to 2010, to empirically determine the half-life of software engineering research topics. In the absence of any consistent and well-accepted methodology for associating research topics to a publication, we have used natural language processing techniques to semi-automatically identify and associate a set of topics with a paper. We adapted measures of half-life already existing in the bibliometric context for our study, and also defined a new measure based on publication and citation counts. We find evidence that some of the identified research topics show a mean half-life of close to 15 years, and there are topics with sustaining interest in the community. We report the methodology of our study in this paper, as well as the implications and utility of our results.

The role of design pattern in the form of software metric and internal code architecture for object-oriented design plays a critical role in software en-gineering in terms of production cost efficiency. This paper discusses about code reusability that is a frequently exercised cost saving methodology in IT produc-tion. After reviewing existing literatures towards study on software metrics, we found that very few studies are witnessed to incline towards code reusability. Hence, we developed a simple analytical model that establishes relationship between the design components of standard software metric and code reusability using case studies of three software projects (Customer Relationship Management project, Supply Chain Management project, and Enterprise Relationship Management project). We also testify our proposal using stochastic based Markov model to find that proposed system can extract significant information of maximized values of code reusability with increasing level of uncertainties of software project methodologies.

Next generation cloud systems will require a paradigm shift in how they are constructed and managed. Conventional control and management platforms are facing considerable challenges regarding flexibility, dependability and security that next generation systems must handle. The cloud computing technology has already contributed in alleviating a number of the problems associated with resource allocation, utilization and management. However, many of the elements of a well-designed cloud environment remain "stiff" and hard to modify and adapt in an integrated fashion. This includes the underlying networking topologies, many aspects of the user control over IaaS, PaaS or SaaS layers, construction of XaaS services, provenance and meta-data collection, to mention but few. In many situations the problem may be due to inadequacy of service abstraction. Software Defined Systems (SDSys) is a concept that help abstract the actual hardware at different layers with software components; one classical example of this abstractions are hypervisors. Such abstraction provides an opportunity for system administrators to construct and manage their systems, more easily, through flexible software layers. SDSys is an umbrella for different software defined subsystems including Software Defined Networking (SDN), Software Defined Storage (SDStorage), Software Defined Servers (Virtualization), Software Defined Data Centers (SDDC), Software Defined Security (SDSec) etc. and ultimately Software Defined Clouds (SDCloud). Individual solutions and seamless integration of these different abstractions remains in many respects a challenge. In this paper, the authors introduce Software Defined Cloud (SDCloud), a novel software defined cloud management framework that integrates different software defined cloud components to handle complexities associated with cloud computing systems. The first part of paper presents, for the first time, an extensive state of the art critical review of different components of software defined systems, constructing the proposed SDCloud. The second part of the paper proposes the novel concept of SDCloud, which is implemented and evaluated for its feasibility, flexibility and potential superiority. A comprehensive survey for Software Defined Systems.Proposing a novel framework for Software Defined Cloud.Integrating different Software Defined Systems components in one platform.Validate applicability of the proposed model using simulation.

Owing to the extreme parallelism and the high component failure rates of tomorrow's exascale, high-performance computing (HPC) system software will need to be scalable, failure-resistant, and adaptive for sustained system operation and full system utilizations. Many of the existing HPC system software are still designed around a centralized server paradigm and hence are susceptible to scaling issues and single points of failure. In this article, we explore the design tradeoffs for scalable system software at extreme scales. We propose a general system software taxonomy by deconstructing common HPC system software into their basic components. The taxonomy helps us reason about system software as follows: (1) it gives us a systematic way to architect scalable system software by decomposing them into their basic components; (2) it allows us to categorize system software based on the features of these components, and finally (3) it suggests the configuration space to consider for design evaluation via simulations or real implementations. Further, we evaluate different design choices of a representative system software, i.e. key-value store, through simulations up to millions of nodes. Finally, we show evaluation results of two distributed system software, Slurm++ (a distributed HPC resource manager) and MATRIX (a distributed task execution framework), both developed based on insights from this work. We envision that the results in this article help to lay the foundations of developing next-generation HPC system software for extreme scales.

development and evaluation is the most difficult task in software engineering. The future of the software industry depends upon the development of software. For this purpose quality is considered essential step in designing software. Quality of software is dependable upon different aspects but the dream of software quality is not feasible without software reliability. Reliability of software is the chance of performing operation without any failure in a particular environment for a specific period. This paper is basically concerned with improving quality of software. The quality is the instrument that can predict future of the software in industry. This paper presents the strategy to measure and maintain quality of software. The research is based on the reviews collected through questionnaire and visits to persons concerned with the designing, maintaining and utilizing software. It also discusses some techniques like CMM, Process Maturity Hierarchy used for measuring the reliability of software. The solution to this problem is to focus on the weaknesses found through the research. The first step towards formulating reliable software is to trace all the facts that are responsible for failure of software. Later each issue will be given individual attention for its resolution. At the end reliable software will be generated.

Today, the influence of information technology has been spreading exponentially, from high level research going on in top labs of the world to the home appliances. Such a huge demand is compelling developers to develop more software to meet the user expectations. As a result reliability has come up as a critical quality factor that cannot be compromised. Therefore, researchers are continuously making efforts to meet this challenge. With this spirit, authors of the paper have proposed a highly structured framework that guides the process of quantifying software reliability, before the coding of the software start. Before presenting the framework, to realize its need and significance, the paper has presented the state-of-the-art on software reliability quantification. The strength of fuzzy set theory has been utilized to prevail over the limitation of subjectivity of requirements stage measures. Salient features of the framework are also highlighted at the end of the paper.

A software quality model is a very useful instrument for software quality evaluation. Researchers have studied the axis of modeling and evaluating software quality and several approaches have been proposed. These approaches were limited to a specific use field and did not offer a quality profile enabling us to evaluate a global software quality model. The evaluation based on International Organization for Standardization (ISO) models has emerged; however, these models do not guide us for their use in a global evaluation approach. In this paper we treat extracted data from an ambient distributed system. Our work presents the following contributions:(i) creating a generic software quality model based on several existing software quality standards, (ii) proposing an instantiation algorithm to extract specified software evaluation model from generic software quality models, (iii) proposing a new global evaluation approach of the specified software evaluation model using measurement metrics and fuzzy logic.

Most of the research effort in the area of software analysis is focused on the perspective of the developer (as in "software developing company") and the ways how the software development process could be improved. However, that is not the only type of software assessment common in the industry. There are also assessments that are commissioned by other parties, such as the primary recipients of the software solutions or courts dealing with legal cases that are related to software products or services. This work presents one such case-study that was performed for a public administration in Italy. The paper describes the assessment itself and also points out the need for more focused research by providing a comparison between developer-oriented and customer-oriented assessment types.

Software development considered to be an important part of software industry. Various metrics, algorithms and reusable process models has been designed but ultimately our main goal is only to find that part which will help us to select the optimal one which may be a metric, algorithm or a reusable software process model. For the various large applications some components need to be built separately and some of the components need to be modified according to the requirement for searching the optimal components. Now a day's component based software engineering considered to be the best approach for the software development at low cost and this software development best approach will totally dependent on the optimal selection of components. The aim of this paper is to describe the characteristics of some selected state of art CBSD models and a new reusable software process model has been designed for the optimal selection of components based on the new optimal algorithm.

2 Abstract: Estimating Reusability near the beginning in the software development life cycle, particularly at design phase, may help the designers to integrate required improvement and corrections for improving overall quality of the developed software. This research paper proposes a framework for reusability estimation that provides step by step solution for reusability estimation of object oriented software. As well as study developed a multivariate regression model ‗Reusability Estimation Model for Object-Oriented software' at design phase of software development process. Proposed model has been mathematically validated through proper statistical measures and contextual explanation has been drawn. This study facilitates the software developers, designer and quality controllers, the inclusion of reusability estimation model to access and quantify software reusability for quality product. Reusability estimation in early stage of software development life cycle always supports the designers to improve the reusability of product class diagram and consequently the reusability of software.

Software Engineering is associated with development of software products using well defined principles, techniques and processes. The result of Software Engineering is an effective and reliable product. The software products have chances to fail during implementation and design phases. The design time testing and reliability measurement can enhance the process of development and their component management to work more effectively for long time. Software Testing is evaluation of the software product against system requirements gathered from users and system specification. That mainly comprises of validation and verification. The reliability analysis concerned with analyzing the system and their functions to get the amount of time when the system and their components works reliably. In this paper, Reliability Engineering based case study on software product development is performed. The concept of Software Engineering and the component based product development, use the Unified Modeling Language (UML) diagrams and create Reliability Block Diagram (RBD). RBDs are used to evaluate entire software components and their sub components to find their reliability according to the number of usages and increasing time factor. Therefore, to analyze the software system using RBD, UML to RBD conversion is required. The UML diagram for online shopping is first explored and then its sub use-case checkout is designed. The sub-case is then re-organized according to the functionality that can be similar to component diagram. The component diagram is used further to convert the software system into the RBD diagram. The result of RBD analysis defined in terms of Block failure rate, Block unreliability Vs. Time, Block Reliability vs. Time, System Reliability vs. Time and the System Reliability statistics. The finding of the experiments shows that the system can be improved through the RBD analysis. Additionally the improvements during the design phases can refine the productivity and reliability of the system.

Use cases have been widely adopted by software engineers to model user-system interaction. However, its fragmented and textual description of functionalities has been inadequate for user-centered design concerns. This has led human-computer interaction professionals to create their own methods and techniques, which has often had the opposite philosophy from that used by software engineers when modeling user-system interactions. Therefore, the present paper proposes the Visual Language for Use Case Description aiming to improve the support of use cases for user-centered design by projecting a common artifact for the communication between both the human-computer interaction and the software engineering communities. To obtain the perceptions of potential users about Visual Language for Use Cases Description, an experimental study involving software development students and professionals was conducted. Copyright © 2015 John Wiley & Sons, Ltd.

A method to measure the weights of nodes and edges of software-based complex network.Forty open-source software systems were chosen to evaluate the proposed technique.Common statistical patterns from the software systems can be identified easily.When compared based on maintenance efforts, their patterns are more distinctive.The proposed method allows software maintainers to identify fault prone classes. Modeling software systems using complex networks can be an effective technique for analyzing the complexity of software systems. To enhance the technique, the structure of a complex network can be extended by assigning a weight to the edges of the complex network to denote the strength of communicational cohesion between a pair of related software components. This paper proposes an approach to represent an object-oriented software system using a weighted complex network in order to capture its structural characteristics, with respect to its maintainability and reliability. Nodes and edges are modeled based on the complexities of classes and their dependencies. Graph theory metrics are applied onto the transformed network with the purpose to evaluate the software system. Comparative analysis is performed using 40 object-oriented software systems, with different levels of maintenance effort. We found that common statistical patterns from the software systems can be identified easily. It is when these software systems are grouped and compared based on their levels of maintenance effort that their statistical patterns are more distinguishable to represent some common behavior and structural complexity of object-oriented software. The evaluations indicate that the proposed approach is capable of identifying software components that violate common software design principles.

This new department aims to elevate the discussion of software architecture beyond code to include all artifacts involved in the software delivery value stream. Here, “value stream” refers to the end-to-end feedback loop of flowing software to customers in a way that maximizes the business value delivered.