Using test case patterns to estimate software development and quality management cost

A novel process to discover test case patterns is proposed. This has led to the construction of a test case patterns catalogue. The catalogue has been analysed to estimate the potential reusability in different software applications. This has shown that 43% of system functions are generally application domain independent, whereas 57% are application domain dependent. Statistical tests showed that the level of specialisation in software systems could be as low as 20%, which supports the direction taken in this research to reuse test case patterns in software engineering activities, in particular, software cost estimation at the early sages of software development.

An empirical investigation on the reusability of design patterns and software packages

Nowadays open-source software communities are thriving. Successful open-source projects are competitive and the amount of source code that is freely available offers great reuse opportunities to software developers. Thus, it is expected that several requirements can be implemented based on open source software reuse. Additionally, design patterns, i.e. well-known solution to common design problems, are introduced as elements of reuse. This study attempts to empirically investigate the reusability of design patterns, classes and software packages. Thus, the results can help developers to identify the most beneficial starting points for white box reuse, which is quite popular among open source communities. In order to achieve this goal we conducted a case study on one hundred (100) open source projects. More specifically, we identified 27,461 classes that participate in design patterns and compared the reusability of each of these classes with the reusability of the pattern and the package that this class belongs to. In more than 40% of the cases investigated, design pattern based class selection, offers the most reusable starting point for white-box reuse. However there are several cases when package based selection might be preferable. The results suggest that each pattern has different level of reusability.     

The use of adapters to support interoperability of components for reusability

Interoperability of heterogeneous applications is defined as the ability for multiple software applications written in different programming languages running on different platforms with different operating systems to communicate and interact with one another over different computer networks. The emerging middleware technologies, including CORBA, COM/DCOM, and Enterprise JavaBeans offer an industrial defacto standard communication infrastructure to support the interoperability of heterogeneous applications in components. However, the implementation of a component suffers from high interaction complexities in the component that seriously degrades the application independence. Software components should be built to be independent of the context in which they are used, allowing them to be reused in many different computing environments. In this paper, we are presenting an adapter to isolate, encapsulate, and manage a component's interactions outside the component. The dynamic interface binding was designed to allow an adapter to examine the signature of the requested services at runtime such as operation names, parameters orders, parameters types, and parameters sizes. The interfaces of interconnecting components are bound at runtime. In addition, the interface language mapping allows an interface in a specific programming language to be automatically generated from an IDL interface. The use of adapters increases the reusability of components and also simplifies the integration of the components to an application.     

Using group support systems for software inspections

Software engineering sometimes appears to be years behind other disciplines in terms of predictability and quality. But we like to argue that the software industry is facing problems now that other industries have yet to face. Constructing a high-quality, million-line program is daunting. Fortunately, progress is occurring and merging two important areas: software process improvement and technological support. The authors describe their experience implementing a group support system (GSS) for software inspections in an industrial environment. The results confirm their belief that such support can improve the efficiency and effectiveness of inspections, provided the inspections are properly conducted     

Generating code for engineering design systems using software patterns

We illustrate here how software engineers developing engineering design systems can introduce patterns into the conceptual modeling techniques that were developed in the database community and integrate them with techniques that are emerging in the object-oriented analysis and engineering design community. The goal is to raise the level of abstraction used to communicate software specifications and to build applications. This will speed the development and improve the quality of engineering design tools. We show by an example how this can be accomplished through an example software pattern from the software engineering discipline (the observer pattern) [12]. We show how patterns can be automatically supported using the general techniques that were developed in the Semantic Objects, Relationships, and Constraints (SORAC) project [20] for the development of tools, for the specification of databases and for building design systems.     

An economic model to estimate software rewriting and replacementtimes

The effort required to service maintenance requests on a software system increases as the software system ages and deteriorates. Thus, it may be economical to replace an aged software system with a freshly written one to contain the escalating cost of maintenance. We develop a normative model of software maintenance and replacement effort that enables us to study the optimal policies for software replacement. Based on both analytical and simulation solutions, we determine the timings of software rewriting and replacement, and hence the schedule of rewriting, as well as the size of the rewriting team as functions of the: user environment, effectiveness of rewriting, technology platform, development quality, software familiarity, and maintenance quality of the existing and the new software systems. Among other things, we show that a volatile user environment often leads to a delayed rewriting and an early replacement (i.e., a compressed development schedule). On the other hand, a greater familiarity with either the existing or the new software system allows for a less-compressed development schedule. In addition, we also show that potential savings from rewriting will be higher if the new software system is developed with a superior technology platform, if programmers' familiarity with the new software system is greater, and if the software system is rewritten with a higher initial quality     

Applying fuzzy neural network to estimate software development effort

The ability to accurately and consistently estimate software development efforts is required by the project managers in planning and conducting software development activities. Since software effort drivers are vague and uncertain, software effort estimates, especially in the early stages of the development life cycle, are prone to a certain degree of estimation errors. A software effort estimation model which adopts a fuzzy inference method provides a solution to fit the uncertain and vague properties of software effort drivers. The present paper proposes a fuzzy neural network (FNN) approach for embedding artificial neural network into fuzzy inference processes in order to derive the software effort estimates. Artificial neural network is utilized to determine the significant fuzzy rules in fuzzy inference processes. We demonstrated our approach by using the 63 historical project data in the well-known COCOMO model. Empirical results showed that applying FNN for software effort estimates resulted in slightly smaller mean magnitude of relative error (MMRE) and probability of a project having a relative error of less than or equal to 0.25 (Pred(0.25)) as compared with the results obtained by just using artificial neural network and the original model. The proposed model can also provide objective fuzzy effort estimation rule sets by adopting the learning mechanism of the artificial neural network.     

Evaluating logistic regression models to estimate software project outcomes

ContextSoftware has been developed since the 1960s but the success rate of software development projects is still low. During the development of software, the probability of success is affected by various practices or aspects. To date, it is not clear which of these aspects are more important in influencing project outcome.ObjectiveIn this research, we identify aspects which could influence project success, build prediction models based on the aspects using data collected from multiple companies, and then test their performance on data from a single organization.MethodA survey-based empirical investigation was used to examine variables and factors that contribute to project outcome. Variables that were highly correlated to project success were selected and the set of variables was reduced to three factors by using principal components analysis. A logistic regression model was built for both the set of variables and the set of factors, using heterogeneous data collected from two different countries and a variety of organizations. We tested these models by using a homogeneous hold-out dataset from one organization. We used the receiver operating characteristic (ROC) analysis to compare the performance of the variable and factor-based models when applied to the homogeneous dataset.ResultsWe found that using raw variables or factors in the logistic regression models did not make any significant difference in predictive capability. The prediction accuracy of these models is more balanced when the cut-off is set to the ratio of success to failures in the datasets used to build the models. We found that the raw variable and factor-based models predict significantly better than random chance.ConclusionWe conclude that an organization wishing to estimate whether a project will succeed or fail may use a model created from heterogeneous data derived from multiple organizations.     

面向软件模糊自适应的UML用例扩展

现有统一建模语言(UML)设施及一般软件自适应工具难以直接支持软件模糊自适应(SFSA)需求分析与设计阶段的建模,为此,提出一种基于UML用例扩展的SFSA需求分析与设计方法--Fuzzy Case。该方法结合SFSA的概念模型,应用UML扩展机制引入新的构造型和标记值,建立了Fuzzy Case的一般模型;同时定义了Fuzzy Case的语法结构,并用对象约束语言(OCL)定义了其语义描述,形成了完整的SFSA建模设施。实例验证表明,与传统方法相比,Fuzzy Case能更清晰地表达SFSA的结构,准确定义软件的内部语义,建模过程更加简单方便,能有效提高SFSA的开发效率。     

基于蚁群算法的软件接口测试用例生成

目前存在的自动化生成接口测试用例的方法有参数配对覆盖法、基于测试依据集的测试用例生成法等,这些算法在用例有效性与耗费资源方面没有足够优势,鉴于此提出基于蚁群方法的软件接口测试用例生成算法,对蚁群算法应用的前提、测试数据生成方法、测试用例生成方法等进行研究。实验分析了算法的优势和不足,提出了有待改进的部分。     

Using the k-core decomposition to analyze the static structure of large-scale software systems

The structures of large-scale software systems are complex and difficult to understand for designers and developers. Traditional software metrics can hardly describe the structural complexity in modern software, and finding a quantitative method to depict and analyze large-scale software is still a challenge. In this paper we use complex networks theory to study software structure; in particular, we visualize the software graph and use the k-core to study it based on a recursive pruning of the least connected vertices. Different types of software are analyzed and some new noticeable properties are found, such as similar coreness, the vital highest core, high-core connecting tendency, and evolution stability. These features suggest that software is organized in a defined hierarchy of increasing centrality from outside to inside. The k-core analysis can help developers to improve software understanding, instruction test, and measurement and evaluation of the system in development.     

用例模型与装配式软件系统的开发

用例是获取需求的主要工具，用例模型成了与用户交流的手段。装配式软件是一种能提高软件适应性和生命力的系统，它是建立在基于组件的工程基础之上，以便系统维护时可以按组件装配、拆卸和替换。讨论了用例模型中的用例如何与组件建立映射关系，并给出装配式软件开发的具体过程。     

Using fold-in and fold-out in the architecture recovery of software systems

In this paper we present an approach to automate the architecture recovery process of software systems. The approach is built on information retrieval and clustering techniques, and, in particular, uses Latent Semantic Indexing (LSI) to get similarities among software entities (e.g., programs or classes) and the k-means clustering algorithm to form groups of software entities that implement similar functionality. In order to improve computational time in the context of the software evolution and then reduce energy waste, the architecture recovery process can be also applied by using fold-in and fold-out mechanisms that, respectively, add and remove software entities to the LSI representation of the understudy software system. The approach has been implemented in a prototype of a supporting software system as an Eclipse plug-in. Finally, to assess the approach and the plug-in, we have conducted an empirical investigation on five open source software systems implemented using the programming languages Java and C/C++. In the investigation special emphasis has been also given to the effect of using the fold-in and fold-out mechanisms.     

Using disability data to estimate design exclusion

Exclusion auditing is a process that can quantitatively evaluate the inclusive merit of different products, or alternative design decisions. The results from such an audit can provide prioritised directions for product improvement and support the business case for reducing the capability levels required to use mainstream products. The 1996/1997 disability follow-up survey, conducted by the Office of National Statistics, is currently the most comprehensive data source for estimating design exclusion in the UK. In this paper, the data source is explained in detail, and a method is presented that uses this data to estimate the exclusion associated with several tasks that occur in series or in parallel, illustrated through worked examples. Having evaluated how many people are excluded, one can investigate why they were excluded, thus generating design insights into how they could be included. Data from the survey is also converted to a series of stylised graphs, which are intended to inspire designers to think about the relationship between the demands required to use a product and the resulting levels of population exclusion.     

软件需求分析中的用例建模研究与应用

需求是软件项目的基础,如何把握用户需求,是项目成功与否的关键.一个灵活的软件需求分析技术,可以帮助开发人员准确获取用户需求.用例建模是面向对象软件开发技术的重要组成内容,它能够完整地捕捉系统的功能性需求,体现用户和系统之间的交互关系.通过一个实例分析,简要介绍如何使用用例建模技术,完成软件需求分析.     

Survival patterns in fast-moving software

To survive, fast-moving software organizations must respond quickly to changing market needs and technological options as well as deliver high-quality products and services at competitive prices. They must therefore constantly improve their capabilities. The authors learned important lessons on how to deal effectively with the dilemmas and opportunities involved in such a goal     

LMES: A localized multi-estimator model to estimate software development effort

Accurate estimation of software development effort is strongly associated with the success or failure of software projects. The clear lack of convincing accuracy and flexibility in this area has attracted the attention of researchers over the past few years. Despite improvements achieved in effort estimating, there is no strong agreement as to which individual model is the best. Recent studies have found that an accurate estimation of development effort in software projects is unreachable in global space, meaning that proposing a high performance estimation model for use in different types of software projects is likely impossible. In this paper, a localized multi-estimator model, called LMES, is proposed in which software projects are classified based on underlying attributes. Different clusters of projects are then locally investigated so that the most accurate estimators are selected for each cluster. Unlike prior models, LMES does not rely on only one individual estimator in a cluster of projects. Rather, an exhaustive investigation is conducted to find the best combination of estimators to assign to each cluster. The investigation domain includes 10 estimators combined using four combination methods, which results in 4017 different combinations. ISBSG, Maxwell and COCOMO datasets are utilized for evaluation purposes, which include a total of 573 real software projects. The promising results show that the estimate accuracy is improved through localization of estimation process and allocation of appropriate estimators. Besides increased accuracy, the significant contribution of LMES is its adaptability and flexibility to deal with the complexity and uncertainty that exist in the field of software development effort estimation.