text stringlengths 17 3.36M | source stringlengths 3 333 | __index_level_0__ int64 0 518k |
|---|---|---|
A large number of safety-critical control systems are based on N-modular redundant architectures, using majority voters on the outputs of independent computation units. In order to assess the compliance of these architectures with international safety standards, the frequency of hazardous failures must be analyzed by developing and solving proper formal models. Furthermore, the impact of maintenance faults has to be considered, since imperfect maintenance may degrade the safety integrity level of the system. In this paper we present both a failure model for voting architectures based on Bayesian Networks and a maintenance model based on Continuous Time Markov Chains, and we propose to combine them according to a compositional multiformalism modeling approach in order to analyze the impact of imperfect maintenance on the system safety. We also show how the proposed approach promotes the reuse and the interchange of models as well the interchange of solving tools. | A new modeling approach to the safety evaluation of N-modular redundant
computer systems in presence of imperfect maintenance | 5,700 |
The trends of design and development of information systems have undergone a variety of ongoing phases and stages. These variations have been evolved due to brisk changes in user requirements and business needs. To meet these requirements and needs, a flexible and agile business solution was required to come up with the latest business trends and styles. Another obstacle in agility of information systems was typically different treatment of same diseases of two patients: business processes and information services. After the emergence of information technology, the business processes and information systems have become counterparts. But these two business halves have been treated under totally different standards. There is need to streamline the boundaries of these both pillars that are equally sharing information system's burdens and liabilities. In last decade, the object orientation has evolved into one of the major solutions for modern business needs and now, SOA is the solution to shift business on ranks of electronic platform. BPM is another modern business solution that assists to regularize optimization of business processes. This paper discusses how object orientation can be conformed to incorporate or embed SOA in BPM for improved information systems. | SOA Embedded in BPM: A High Level View of Object Oriented Paradigm | 5,701 |
In software modelling, the designers have to produce UML visual models with software constraints. Similarly, in business modelling, designers have to model business processes using business constraints (business rules). Constraints are the key components in the skeleton of business or software models. A designer has to write constraints to semantically compliment business models or UML models and finally implementing the constraints into business processes or source code. Business constraints/rules can be written using SBVR (Semantics of Business Vocabulary and Rules) while OCL (Object Constraint Language) is the well-known medium for writing software constraints. SBVR and OCL are two significant standards from OMG. Both standards are principally different as SBVR is typically used in business domains and OCL is employed to compliment software models. However, we have identified a few similarities in both standards that are interesting to study. In this paper, we have performed a comparative analysis of both standards as we are looking for a mechanism for automatic transformation of SBVR to OCL. The major emphasis of the study is to highlight principal features of SBVR and OCL such as similarities, differences and key parameters on which these both standards can work together. | SBVR vs OCL: A Comparative Analysis of Standards | 5,702 |
Software verification of evolving systems is challenging mainstream methodologies and tools. Formal verification techniques often conflict with the time constraints imposed by change management practices for evolving systems. Since changes in these systems are often local to restricted parts, an incremental verification approach could be beneficial. This paper introduces SiDECAR, a general framework for the definition of verification procedures, which are made incremental by the framework itself. Verification procedures are driven by the syntactic structure (defined by a grammar) of the system and encoded as semantic attributes associated with the grammar. Incrementality is achieved by coupling the evaluation of semantic attributes with an incremental parsing technique. We show the application of SiDECAR to the definition of two verification procedures: probabilistic verification of reliability requirements and verification of safety properties. | A Syntactic-Semantic Approach to Incremental Verification | 5,703 |
This paper describes a practical method of developing custom HPC software products using a store of libraries and tools independent from the OS called a "garden". All dependencies from the product to libraries of the underlying OS distribution are carefully severed, isolating the package from instability due to system upgrades and ensuring repeatable deterministic builds on different flavors of Linux. The method also guarantees multiple versions of a software product may exist together and function correctly, greatly facilitating upgrade and rollback. The method is the first known system to expose all past software versions to the designer, and support deterministic single-package rollback without affecting other installed software. An application of this method for building a high performance trading system in C++ is presented. | The Software Garden | 5,704 |
Web services growth makes the composition process a hard task to solve. This numerous interacting elements can be adequately represented by a network. Discovery and composition can benefit from the knowledge of the network structure. In this paper, we investigate the topological properties of two models of syntactic and semantic Web services composition networks: dependency and interaction. Results show that they share a similar organization characterized by the small-world property, a heavy-tailed degree distribution and a low transitivity value. Furthermore, the networks are disassortative. | A Comparative Study of Web Services Composition Networks | 5,705 |
Web services represent a system with a huge number of units and many various and complex interactions. Complex networks as a tool for modelling and analyzing natural environments seem to be well adapted to such a complex system. To describe a set of Web services we propose three Web services network models based on the notions of dependency, interaction and similarity. Using the WS-NEXT extractor we instantiate the models with a collection of Web services descriptions. We take advantage of complex network properties to provide an analyzis of the Web services networks. Those networks and the knowledge of their toplogical properties can be exploited for the discovery and composition processes. | Analyzing Web Services Networks: a WS-NEXT Application | 5,706 |
Web services substitution is one of the most challenging tasks for automating the composition process of multiple Web services. It aims to improve performances and to deal efficiently with Web services failures. Many existing solutions have approached the problem through classification of substitutable Web services. To go a step further, we propose in this paper a network based approach where nodes are Web services operations and links join similar operations. Four similarity measures based on the comparison of input and output parameters values of Web services operations are presented. A comparative evaluation of the topological structure of the corresponding networks is performed on a benchmark of semantically annotated Web services. Results show that this approach allows a more detailed analysis of substitutable Web services. | Similartity Network For Semantic Web Services Substitution | 5,707 |
In order to deal efficiently with the exponential growth of the Web services landscape in composition life cycle activities, it is necessary to have a clear view of its main features. As for many situations where there is a lot of interacting entities, the complex networks paradigm is an appropriate approach to analyze the interactions between the multitudes of Web services. In this paper, we present and investigate the main interactions between semantic Web services models from the complex network perspective. Results show that both parameter and operation networks exhibit the main characteristics of typical real-world complex networks such as the small-world property and an inhomogeneous degree distribution. These results yield valuable insight in order to develop composition search algorithms, to deal with security threat in the composition process and on the phenomena which characterize its evolution. | On Topological Structure of Web Services Networks for Composition | 5,708 |
Service oriented architecture is more and more used in the companies, The importance of the service orientation and its advantages with the information system of the company, confront us to a new challenge. It is primarily to ensure the decision aspect of the information system of company by adopting Services Orientated Architecture like support architecture. This engineering must ensure on the one hand the flexibility of the information system and on the oth-er hand, avoids the redevelopment of the system by the decisions request. In the actual position, several obstacles force the installation of the SOA within the company. It is basically a question of the lack of method to be implemented to define the services architecture within the information system of the company which takes account the decisional aspect. Moreover, there's no existing works which treat this challenge. On the basis of these notes, we are interested, in this paper, on the develop-ment of a three-dimensional new architecture for the integration of the deci-sional aspect in SOA architectures, so that they are used perfectly. The proposal takes support, mainly, on the use of a coupling MAS-SOA. To demonstrate the application of our proposition, we use two study cases: project management and Evapo-transpiration. | Endow a service-oriented architecture by a decisional aspect | 5,709 |
In order to ensure high availability of Web services, recently, a new approach was proposed based on the use of communities. In composition, this approach consists in replacing the failed Web service by another web service joining a community offering the same functionality of the service failed. However, this substitution may cause inconsistency in the semantic composition and alter its mediation initially taken to resolve the semantic heterogeneities between Web services. This paper presents a context oriented solution to this problem by forcing the community to adopt the semantic of the failed web service before the substitution in which all inputs and outputs to/from the latter must be converted according to this adopted semantic, avoiding any alteration of a semantic mediation in web service composition. | Vers une Substitution des Services Web sans Inconsistance Sémantique | 5,710 |
A software element defined in one place is typically used in many places. When it is changed, all its occurrences may need to be changed too, which can severely hinder software evolution. This has led to the support of encapsulation in modern programming languages. Unfortunately, as is shown in this paper, this is not enough to express all the constraints that are needed to decouple programming elements that evolve at different paces. In this paper we show that: a language can be defined to easily express very general coupling constraints; violations to these constraints can be detected automatically. We then demonstrate several places where the need for coupling constraints arose in open-source Java projects. These constraints were expressed in comments when explicit constraints would have enabled automatic treatment. | The Case for Explicit Coupling Constraints | 5,711 |
Detailed description of procedures around architecture reviews. In order to succeed in building and deploying complex software solutions, an architecture is essential. For many in the industry structured reviews of these architectures is also de rigor. Practices for such reviews have been developed and reported on for years. One aspect that does not receive as much attention but is no less important is the relationship between these architectures and the requirements for deploying them into production environments. At Wolters Kluwer's Corporate Legal Services we first established a typical architecture review process and then established a two phase production preparation review process. This paper describes in detail how these practices work and some of the technical results of these reviews including the frequency and style of the reviews, the process automation around them, and the number and nature of some of the technical flaws eliminated by enforcing these reviews. This paper lays the ground work for others who would be interested in following similar practices. | Architecture and Production Readiness Reviews in Practice | 5,712 |
Software requirements are key elements that contribute to the quality and users satisfaction of the final system. In this work, Requirements Engineering (RE) of web sites is presented using an organizational semiotics perspective. They are shown as being part of an organization, with particular practices, rules and views considering stakeholders several differences and opinions. The main contribution of this paper is to relate an experience, from elicitation to validation, showing how organizational semiotics artifacts were exploited in a collaborative and participatory way to RE of a web portal. A case study is described in order to demonstrate the feasibility of using such artifacts to RE when we think about the system as being part of a social organization. | Requirements Engineering of a Web Portal using Organizational Semiotics
Artifacts and Participatory Practices | 5,713 |
The development of web applications that manipulate geo-referenced information is often supported by Application Programming Interfaces (APIs), al-lowing a fast development cycle for high quality applications. APIs can be used by programmers with different expertise levels and choosing an adequate API may have a dramatic impact on the productivity achieved by those programmers. Our goal is to compare maps APIs with respect to their usability. We compare three different APIs: the Google Maps JavaScript API, the ArcGIS API for JavaScript, and the OpenLayers JavaScript Mapping Library. Our comparison is supported by a set of software metrics and is performed in two orthogonal ways: the comparison of three implementations of the same system prototype, each using one of the APIs under scrutiny; the comparison of the APIs specifications. The main results of the study are related to the size of the APIs, with the Google API being significantly smaller than the others. | A Comparison of Maps Application Programming Interfaces | 5,714 |
Often during the requirements engineering (RE) process, the value of a requirement is assessed, e.g., in requirement prioritisation, release planning, and trade-off analysis. In order to support these activities, this research evaluates Goal Oriented Requirements Engineering (GORE) methods for the description of a requirement's value. Specifically, we investigate the goal-to-goal contribution relationship for its ability to demonstrate the value of a requirement, and propose that it is enriched with concepts such as correlation, confidence, and utility. | Analysing the Assumed Benefits of Software Requirements | 5,715 |
The process of creating working software from source code and other components (like libraries, database files, etc.) is called "software build". Apart from linking and compiling, it can include other steps like automated testing, static code analysis, documentation generation, deployment and other. All that steps can be automated using a build description of some sort (e.g. script). This article classifies the automatic software build processes beginning at build script and reaching the various types of continuous integration. | Classification of automatic software build methods | 5,716 |
Detected a system error of the project ETONN&EIAS.NET, which consists in the use of the developers EIAS.NET the Windows operating system in the software EIAS.NET, which in accordance with the requirements of the specification for the project EIAS.NET should provide information exchange in real time . It is concluded that it is impossible to meet the requirement specification for the project EIAS.NET about providing work ETONN/ETNaSP with the support of EIAS / EIAS.NET in real time, providing the use of the Windows operating system in the software EIAS.NET. | System error of project ETONN and EIAS | 5,717 |
Software is primarily developed for people by people and human factors must be studied in all software engineering phases. Creativity is the source to improvise solutions to problems for dominating complex systems such as software development. However, there is a lack of knowledge in what creativity is in software development and what its dynamics are. This study describes the current state of the research plan towards a theory on creativity in software development. More specifically, it (1) states the motivation for studying creativity in software development under a multidisciplinary view; it (2) provides a first review of the literature identifying the shortcomings in the field; it (3) proposes a research design, which includes rarely employed methods in software engineering. To understand creativity in software development will provide a better knowledge of the software construction process and how individuals intellectually contribute to the creation of better, innovative products. | The Dynamics of Creativity in Software Development | 5,718 |
This paper provides an overview of the CODA framework for modelling and refinement of component-based embedded systems. CODA is an extension of Event-B and UML-B and is supported by a plug-in for the Rodin toolset. CODA augments Event-B with constructs for component-based modelling including components, communications ports, port connectors, timed communications and timing triggers. Component behaviour is specified through a combination of UML-B state machines and Event-B. CODA communications and timing are given an Event-B semantics through translation rules. Refinement is based on Event-B refinement and allows layered construction of CODA models in a consistent way. | Modelling and Refinement in CODA | 5,719 |
Object-oriented (OO) inheritance allows the definition of families of classes in a hierarchical way. In behavioural inheritance, a strong version, it should be possible to substitute an object of a subclass for an object of its superclass without any observable effect on the system. Behavioural inheritance is related to formal refinement, but, as observed in the literature, the refinement constraints are too restrictive, ruling out many useful OO subclassings. This paper studies behavioural inheritance in the context of ZOO, an object-oriented style for Z. To overcome refinement's restrictions, this paper proposes relaxations to the behavioural inheritance refinement rules. The work is presented for Z, but the results are applicable to any OO language that supports design-by-contract. | Relaxing Behavioural Inheritance | 5,720 |
Traditional algorithms for detecting differences in source code focus on differences between lines. As such, little can be learned about abstract changes that occur over time within a project. Structural differencing on the program's abstract syntax tree reveals changes at the syntactic level within code, which allows us to further process the differences to understand their meaning. We propose that grouping of changes by some metric of similarity, followed by pattern extraction via antiunification will allow us to identify patterns of change within a software project from the sequence of changes contained within a Version Control System (VCS). Tree similarity metrics such as a tree edit distance can be used to group changes in order to identify groupings that may represent a single class of change (e.g., adding a parameter to a function call). By applying antiunification within each group we are able to generalize from families of concrete changes to patterns of structural change. Studying patterns of change at the structural level, instead of line-by-line, allows us to gain insight into the evolution of software. | Identifying change patterns in software history | 5,721 |
As opposed to more mature subjects, software engineering lacks general theories to establish its foundations as a discipline. The Essence Theory of software engineering (Essence) has been proposed by the Software Engineering Methods and Theory (SEMAT) initiative. Essence goal is to develop a theoretically sound basis for software engineering practice and its wide adoption. Essence is yet far from reaching academic and industry adoption. Reasons include a struggle to foresee its utilization potential and the lack of tools implementing it. SEMAT Accelerator (SematAcc) is a Web-positioning tool for a software engineering endeavor, which implements the SEMAT's Essence kernel. SematAcc allows using Essence, thus helping to understand it. The tool enables teaching, adopting, and researching Essence in controlled experiments and case studies. | A Web-based modeling tool for the SEMAT Essence theory of Software
Engineering | 5,722 |
Analysing the strategic alignment of software requirements primarily provides assurance to stakeholders that the software-to-be will add value to the organisation. Additionally, such analysis can improve a requirement by disambiguating its purpose and value, thereby supporting validation and value-oriented decisions in requirements engineering processes, such as prioritisation, release planning, and trade-off analysis. We review current approaches that could enable such an analysis. We focus on Goal Oriented Requirements Engineering methodologies, since goal graphs are well suited for relating software goals to business goals. However, we argue that unless the extent of goal-goal contribution is quantified with verifiable metrics, goal graphs are not sufficient for demonstrating the strategic alignment of software requirements. Since the concept of goal contribution is predictive, what results is a forecast of the benefits of implementing software requirements. Thus, we explore how the description of the contribution relationship can be enriched with concepts such as uncertainty and confidence, non-linear causation, and utility. We introduce the approach using an example software project from Rolls-Royce. | Towards an Approach for Analysing the Strategic Alignment of Software
Requirements using Quantified Goal Graphs | 5,723 |
Nowadays, better driving also means better braking. To this end, vehicle designers must find all failures during the design phase of antilock braking systems which play an important role in automobiles safety. However, mechatronic systems are so complex and failures can be badly identified. So it is necessary to propose a design approach of an antilock braking system which will be able to avoid wheels locking during braking and maintain vehicle stability. This paper describes this approach, in which we model the functional and the dysfunctional behavior of an antilock braking system using stopwatch Petri nets. | Towards a Good ABS Design for more Reliable Vehicles on the Roads | 5,724 |
Today-s business environment is very much dynamic, and organisations are constantly changing their software requirements to adjust with new environment. They also demand for fast delivery of software products as well as for accepting changing requirements. In this aspect, traditional plan-driven developments fail to meet up these requirements. Though traditional software development methodologies, such as life cycle-based structured and object oriented approaches, continue to dominate the systems development few decades and much research has done in traditional methodologies, Agile software development brings its own set of novel challenges that must be addressed to satisfy the customer through early and continuous delivery of the valuable software. It is a set of software development methods based on iterative and incremental development process, where requirements and development evolve through collaboration between self-organizing, cross-functional teams that allows rapid delivery of high quality software to meet customer needs and also accommodate changes in the requirements. In this paper, we significantly identify and describe the major factors, that Agile development approach improves software development process to meet the rapid changing business environments. We also provide a brief comparison of agile development methodologies with traditional systems development methodologies, and discuss current state of adopting agile methodologies. We speculate that from the need to satisfy the customer through early and continuous delivery of the valuable software, Agile software development is emerged as an alternative to traditional plan-based software development methods. The purpose of this paper, is to provide an in-depth understanding, the major benefits of agile development approach to software development industry, as well as provide a comparison study report of ASDM over TSDM. | Comparative Study on Agile software development methodologies | 5,725 |
Software testing framework can be stated as the process of verifying and validating that a computer program/application works as expected and meets the requirements of the user. Usually testing can be done manually or using tools. Manual testing can be time consuming and tedious, also it requires heavy investment of human resources. Testing tools in fact have many advantages and are widely used nowadays, but also has several disadvantages. One particular problem is that human intervention is no longer needed. Testing tools are of high cost and so, it cannot be used for small companies. Hence in this paper we propose Agent based testing, which is a fast growing approach in testing field. The proposed system (ABSTF) has to reduce the application testing moment, easily find out bug and solve the bug by Regression Testing. Here by we are going to use a safe efficient regression selection technique algorithm to selectively retest the modified program. We also use Traceability relation of completeness checking for agent oriented system, which identifies missing elements in entire application and classifies defect in the testing moment. With the ability of agents to act autonomously, monitoring code changes and generating test cases for the changed version of code can be done dynamically. | Agent Based Software Testing Framework (ABSTF) for Application
Maintenance | 5,726 |
In this paper, we study how object-oriented classes are used across thousands of software packages. We concentrate on "usage diversity'", defined as the different statically observable combinations of methods called on the same object. We present empirical evidence that there is a significant usage diversity for many classes. For instance, we observe in our dataset that Java's String is used in 2460 manners. We discuss the reasons of this observed diversity and the consequences on software engineering knowledge and research. | Empirical Evidence of Large-Scale Diversity in API Usage of
Object-Oriented Software | 5,727 |
The upcoming technology support for semantic web promises fresh directions for Software Engineering community. Also semantic web has its roots in knowledge engineering that provoke software engineers to look for application of ontology applications throughout the Software Engineering life cycle. The internal components of a semantic web are light weight and may be of less quality standards than the externally visible modules. In fact the internal components are generated from external (ontological) component. That is the reason agile development approaches such as feature driven development are suitable for applications internal component development. As yet there is no particular procedure that describes the role of ontology in the processes. Therefore we propose an ontology based feature driven development for semantic web application that can be used form application model development to feature design and implementation. Features are precisely defined in the OWL-based domain model. Transition from OWL based domain model to feature list is directly defined in transformation rules. On the other hand the ontology based overall model can be easily validated through automated tools. Advantages of ontology-based feature Driven development are also discussed. | Ontology Based Feature Driven Development Life Cycle | 5,728 |
Software measurement programs have emerged as compounds of several measurement activities that are pursued as part of a combined effort of several parties within a software organization, based on interests that the organization has regarding the assessment of the different elements that intervene in the development of software. This paper recognizes design of measurement programs as an essential activity that, up until now, has been studied extensively, however, only in what respects to the content of the programs. In addition, proper specification for this kind of programs, accounting for preciseness and unambiguity, to facilitate maintenance, evolution, and execution has not been thoroughly considered. A methodology for designing programs that embody these and some other desirable features is presented. The methodology is built in solid ground. From software measurement literature, a goal-oriented approach is considered for building the content of the program. On the other hand, a successful technique from software development as modularization is utilized to give coherent structure to the measurement program. | A Design Methodology for Software Measurement Programs | 5,729 |
We propose a method to write and check a specification including quantifiers using behaviors, i.e., input-output pairs. Our method requires the following input from the user: (1) answers to a finite number of queries, each of which presents some behavior to the user, who responds informing whether the behavior is "correct" or not; and (2) an "equivalence" theory (set of formulae), which represents the users opinion about which pairs of behaviors are equivalent with respect to the specification; and (3) a "vocabulary", i.e., a set of formulae which provide the basic building blocks for the specification to be written. Alternatively, the user can specify a type theory and a simple relational grammar, and our method can generate the vocabulary and equivalence theories. Our method automatically generates behaviors using a satisfiability modulo theory solver. Since writing a specification consists of formalizing ideas that are initially informal, there must, by definition, be at least one "initial" step where an informal notion is formalized by the user in an ad hoc manner. This step is the provision of the equivalence theory and vocabulary; we call it the primitive formalization step. We contend that it is considerably easier to write an equivalence theory and vocabulary than to write a full-blown formal specification from scratch, and we provide experimental evidence for this claim. We also show how vocabularies can be constructed hierarchically, with a specification at one level providing vocabulary material for the next level. | Specification Construction Using Behaviours, Equivalences, and SMT
Solvers | 5,730 |
This document aims at specifying the requirements and capturing the needs of users for building a softbody simulation system. This system has different applications ranging from computer games to surgery training which facilitates the creation and visualization of a certain softbody object. It also allows users to interact with created object at real time. A softbody or deformable object is an object whose shape changes due to an external force. Deformation type varies depending on the amount of object deformation. Each object can have multiple layers and each layer can have its own properties. So layers can be different in pressure, density and motion. | Toward Recovering Complete SRS for Softbody Simulation System and a
Sample Application -- a Team 9a SOEN6481 W13 Project Report | 5,731 |
Hospitals are distributed across geographical areas and it is important for all hospitals to share information as well as integrate their systems for effective researching and health delivery. Health personals and institutions in need of information from hospitals with respect to geographical areas can easily do researches on patients, treatments, disease outbreaks, and effects of drugs. This research work is aimed at integrating of database systems of hospital across geographical areas via a service bus. A centralized service bus was used to facilitate interoperability of applications across platforms and enhance communication within the hospital infrastructure as well as creating enabling environment for new layer of abstractions to be added without modification of the entire system. Concept of Service Oriented Architecture with web services was used for rapid integration solution in solving the challenges faced during integration of multiple incompatible applications. | Using SOA with Web Services for effective Integration of Hospital
Information Systems via an Enterprise Service Bus | 5,732 |
Medicines exist for combating illnesses and drug stores provide an outlet for consumers to gain access to these drugs. However, due to various factors such as cost of production, accessibility and legal issues as well as distribution factors, availability of these drugs at any location cannot be guaranteed at all times. There is need for individuals and organizations such as hospitals to be able to locate required drugs within given geographical vicinity. This is of immense importance especially during emergencies, travel, and in cases where the drugs are uncommon. This research work is aimed at solving this problem by designing a system that integrates all drugstores. The integration of the drug stores will be based on SOA concepts with web services via a central service bus. The database systems of the drug stores will be integrated via a service bus such that drugs can easily be searched for and the results will be displayed based on its availability. Drugs can easily be searched for within geographically distributed pharmaceutical databases as well as consumption of drugs with relation to geographical locations can easily be monitored and tracked. This will make it easy for health institutions to research on drug consumption patterns across geographical areas and also control their usage. | Using SOA with Web Services for effective data integration of Enterprise
Pharmaceutical Information Systems | 5,733 |
Necessity of different competencies with high level of knowledge makes it inevitable that software development is a team work. With the today's technology, teams can communicate both synchronously and asynchronously using different online collaboration tools throughout the world. Researches indicate that there are many factors that affect the team success and in this paper, effect of individual success on globally distributed team performance will be analyzed. Student team projects undertaken by other researchers will be used to analyze collected data and conclusions will be drawn for further analysis. | Effects of Individual Success on Globally Distributed Team Performance | 5,734 |
Programming models for concurrency are optimized for dealing with nondeterminism, for example to handle asynchronously arriving events. To shield the developer from data race errors effectively, such models may prevent shared access to data altogether. However, this restriction also makes them unsuitable for applications that require data parallelism. We present a library-based approach for permitting parallel access to arrays while preserving the safety guarantees of the original model. When applied to SCOOP, an object-oriented concurrency model, the approach exhibits a negligible performance overhead compared to ordinary threaded implementations of two parallel benchmark programs. | Handling Parallelism in a Concurrency Model | 5,735 |
In this paper we look at the growth of distributed object stores (DOS) and examine the underlying mechanisms that guide their use and development. Our focus is on the fundamental principles of operation that define this class of system, how it has evolved, and where it is heading as new markets expand beyond the use originally presented. We conclude by speculating about how object stores as a class must evolve to meet the more demanding requirements of future applications. | Distributed Object Store Principles of Operation The Case for
Intelligent Storage | 5,736 |
Precisely and automatically detection of faults in programs, is a software engineering dream. Every effort in this regard takes us one step closer to realizing it. Many efforts have been taken from the people of these areas on testing, verification and debugging. We are proposing such effort for the research community of this domain is using path conditions to generate a minimal set of PLOFC (possible lines of faulty code). It's a run time method that will effectively bring the minimal possible set of faulty lines of code through the help of path conditions and some heuristics involved. In this paper we are generating possible fault locations from programs using path conditions which can put positive impact on the static analysis of programs. Further we discuss the basic ideas regarding path conditions, the theory, and first analysis results. This work is based on a previous work that uses the variable dependences for fault detection. We showed some examples to the applicable of this idea and can be useful for software verification. | Path Conditions Help to Locate and Localize Faults from Programs | 5,737 |
Software project scope verification is a very important process in project scope management and it needs to be performed properly and thoroughly so as to avoid project rework and scope creep. Moreover, software scope verification is crucial in the process of delivering exactly what the customer requested and minimizing project scope changes. Well defined software scope eases the process of scope verification and contributes to project success. Furthermore, a deliverable-oriented WBS provides a road map to a well defined software scope of work. It is on the basis of this that this paper extends the use of deliverable-oriented WBS to that of scope verification process. This paper argues that a deliverable-oriented WBS is a tool for software scope verification. | Work Breakdown Structure: A Tool for Software Project Scope Verification | 5,738 |
Testability is the probability whether tests will detect a fault, given that a fault in the program exists. How efficiently the faults will be uncovered depends upon the testability of the software. Various researchers have proposed qualitative and quantitative techniques to improve and measure the testability of software. In literature, a plethora of reliability growth models have been used to assess and measure the quantitative quality assessment of software during testing and operational phase. The knowledge about failure distribution and their complexity can improve the testability of software. Testing effort allocation can be made easy by knowing the failure distribution and complexity of faults, and this will ease the process of revealing faults from the software. As a result, the testability of the software will be improved. The parameters of the model along with the proportion of faults of different complexity to be removed from the software have been presented in the paper .We have used failure data of two object oriented software developed under open source environment namely MySQL for python and Squirrel SQL Client for estimation purpose | Improving the Testability of Object-oriented Software during Testing and
Debugging Processes | 5,739 |
Automatic test data generation (ATG) is a major topic in software engineering. In this paper, we seek to bridge the gap between the coverage criteria supported by symbolic ATG tools and the most advanced coverage criteria found in the literature. We define a new testing criterion, label coverage, and prove it to be both expressive and amenable to efficient automation. We propose several innovative techniques resulting in an effective black-box support for label coverage, while a direct approach induces an exponential blow-up of the search space. Initial experiments show that ATG for label coverage can be achieved at a reasonable cost and that our optimisations yield very significant savings. | Efficient Leverage of Symbolic ATG Tools to Advanced Coverage Criteria | 5,740 |
Group brainstorming is a well-known idea generation technique, which plays a key role in software development processes. Despite this, the relevant literature has had little to offer in advancing our understanding of the effectiveness of group brainstorming sessions. In this paper we present a research-in-progress on brainstorming while walking, which is a practice built upon the relationship between thinking and walking. The objective is to better understand how to conduct group brainstorming effectively. We compared two brainstorming sessions, one performed during a mountain walk, the other traditionally in a room. Three preliminary findings are obtained: walking can lead to an effective idea generation session; brainstorming while walking can encourage team members to participate in and contribute to the session in an equal manner; and it can help a team to maintain sustainable mental energy. Our study opens up an avenue for future exploration of effective group brainstorming practices. | Traverse the landscape of the mind by walking: an exploration of a new
brainstorming practice | 5,741 |
Service orientation fosters a high-level model for distributed applications development, which is based on the discovery, composition and reuse of existing software services. However, the heterogeneity among current service-oriented technologies renders the important task of service discovery tedious and ineffective. This dissertation proposes a new approach to address this challenge. Specifically, it contributes a framework supporting the unified discovery of heterogeneous services, with a focus on web, peer-to-peer, and grid services. The framework comprises a service query language and its enacting service discovery engine. Overall, the proposed solution is characterized by generality and flexibility, which are ensured by appropriate abstractions, extension points, and their sup- porting mechanisms. The viability, performance, and effectiveness of the proposed framework are demonstrated by experimental measurements. | Development of a language and its enacting engine for the unified
discovery of heterogeneous services | 5,742 |
This case study is an update-in-place refactoring transformation on UML class diagrams. Its aim is to remove clones of attributes from a class diagram, and to identify new classes which abstract groups of classes that share common data features. It is used as one of a general collection of transformations (such as the removal of redundant inheritance, or multiple inheritance) which aim to improve the quality of a specification or design level class diagram. The transformation is a typical example of a model refactoring, and illustrates the issues involved in such transformations. | Case study: Class diagram restructuring | 5,743 |
According to Wikipedia, The Mining Software Repositories (MSR) field analyzes the rich data available in software repositories, such as version control repositories, mailing list archives, bug tracking systems, issue tracking systems, etc. to uncover interesting and actionable information about software systems, projects and software engineering. The MSR field has received a great deal of attention and has now its own research conference : http://www.msrconf.org/. However performing MSR studies is still a technical challenge. Indeed, data sources (such as version control system or bug tracking systems) are highly heterogeneous. Moreover performing a study on a lot of data sources is very expensive in terms of execution time. Surprisingly, there are not so many tools able to help researchers in their MSR quests. This is why we created the Harmony platform, as a mean to assist researchers in performing MSR studies. | The Harmony Platform | 5,744 |
Commit is an important operation of revision control for open-source software (OSS). Recent research has been pursued to explore the statistical laws of such an operation, but few of those papers conduct empirical investigations on commit interval (i.e., the waiting time between two consecutive commits). In this paper, we investigated software developer's collective and individual commit behavior in terms of the distribution of commit intervals, and found that 1) the data sets of project-level commit interval within both the lifecycle and each release of the projects analyzed roughly follow power-law distributions; and 2) lifecycle- and release-level collective commit interval on class files can also be best fitted with power laws. These findings reveal some general (collective) collaborative development patterns of OSS projects, e.g., most of the waiting times between two consecutive commits to a central repository are short, but only a few of them experience a long duration of waiting. Then, the implications of what we found for OSS research were outlined, which could provide an insight into understanding OSS development processes better based on software developers' historical commit behavior. | Dynamics of Open-Source Software Developer's Commit Behavior: An
Empirical Investigation of Subversion | 5,745 |
This is the world of information. The ever growing field Information Technology has its many advanced notable features which made it what it was now today. In this world, the information has to be processed, clearly distributed and must be efficiently reachable to the end users intended for that. Otherwise we know it lead to disastrous situations. The other coin of the same phase is it is absolutely necessary to know any bugs that are hither to faced by the end users. The project Bug Tracking and Reporting System aims to provide the solution for that. The Bug Tracker can be made from any two types. The first one being the system side, the other being the services side. Our project deals with the second one. The paper is wholly dedicated to tracking the bugs that are hither by arise. The administrator maintains the master details regarding to the bugs id, bugs type, bugs description, bugs severity, bugs status, user details. The administrator too has the authority to update the master details of severity level, status level, etc, modules of the paper. The administrator adds the users and assign them responsibility of completing the paper. Finally on analyzing the paper assigned to the particular user, the administrator can track the bugs, and it is automatically added to the tables containing the bugs, by order of severity and status. The administrator can know the information in tact the various paper s assigned to various users, their bug tracking status, their description etc in the form of reports from time to time. | Bug Tracking and Reporting System | 5,746 |
The necessity to adapt current products and services into a way of working environmentally friendly is already a social and economic demand. Although the GreenIT can be considered a mature discipline, software sustainability, both in its process and its use, has not begun to be a topic of interest until the last few years. In this sense we think is fundamental to define what we consider that is software sustainability and how to evaluate it properly. | Towards a Software Product Sustainability Model | 5,747 |
The success of the VisIt visualization system has been wholly dependent upon the culture and practices of software development that have fostered its welcome by users and embrace by developers and researchers. In the following paper, we, the founding developers and designers of VisIt, summarize some of the major efforts, both successful and unsuccessful, that we have undertaken in the last thirteen years to foster community, encourage research, create a sustainable open-source development model, measure impact, and support production software. We also provide commentary about the career paths that our development work has engendered. | VisIt: Experiences with Sustainable Software | 5,748 |
The vast majority of the long tail of scientific software, the myriads of tools that implement the many analysis and visualization methods for different scientific fields, is highly specialized, purpose-built for a research project, and has to rely on community uptake and reuse for its continued development and maintenance. Although uptake cannot be controlled over even guaranteed, some of the key factors that influence whether new users or developers decide to adopt an existing tool or start a new one are about how easy or difficult it is to use or enhance a tool for a purpose for which it was not originally designed. The science of software engineering has produced techniques and practices that would reduce or remove a variety of barriers to community uptake of software, but for a variety of reasons employing trained software engineers as part of the development of long tail scientific software has proven to be challenging. As a consequence, community uptake of long tail tools is often far more difficult than it would need to be, even though opportunities for reuse abound. We discuss likely reasons why employing software engineering in the long tail is challenging, and propose that many of those obstacles could be addressed in the form of a cross-cutting non-profit center of excellence that makes software engineering broadly accessible as a shared service, conceptually and in its effect similar to shared instrumentation. | Software Engineering as Instrumentation for the Long Tail of Scientific
Software | 5,749 |
We present a set of common themes and recommendations extracted from in depth interviews with the leaders of 12 distinct cyberinfrastructure software projects. These interviews were conducted as part of a larger study to identify and elucidate the best practices and management models that lead to sustainability for cyberinfrastructure software. Respondents in a formal survey of cyberinfrastructure users identified these projects as good examples of sustained software initiatives. While there is clearly no single method or plan that will guarantee sustainability for all projects, we can draw general guidance from these exemplars. This paper presents the common themes, ideas, and recommendations that emerged from those interviews. | Initial Findings from a Study of Best Practices and Models for
Cyberinfrastructure Software Sustainability | 5,750 |
We present the integration of the OpenIGTLink network protocol for image-guided therapy (IGT) with the medical prototyping platform MeVisLab. OpenIGTLink is a new, open, simple and extensible network communication protocol for IGT. The protocol provides a standardized mechanism to connect hardware and software by the transfer of coordinate transforms, images, and status messages. MeVisLab is a framework for the development of image processing algorithms and visualization and interaction methods, with a focus on medical imaging. The integration of OpenIGTLink into MeVisLab has been realized by developing a software module using the C++ programming language. As a result, researchers using MeVisLab can interface their software to hardware devices that already support the OpenIGTLink protocol, such as the NDI Aurora magnetic tracking system. In addition, the OpenIGTLink module can also be used to communicate directly with Slicer, a free, open source software package for visualization and image analysis. The integration has been tested with tracker clients available online and a real tracking system. | Integration of the OpenIGTLink Network Protocol for Image-Guided Therapy
with the Medical Platform MeVisLab | 5,751 |
In the software development required a fidelity and accuracy in determining the size or value of the software to fit the operation is executed. Various methods of calculation has been widely applied to estimate the size, and one of them is by using the method of Function Point Analysis (FPA). The method is then applied by author to measure the complexity of an academic information system by using the two modeling approaches, namely object oriented and structural models. Measurements in this paper consists of several stages, namely describing the information system that will be built into the UML models and structured. Then the model is analyzed by calculating Crude Function Points (CRP), Relative Complexity Adjustment Factor (RCAF), and then calculate its function point. From the result of a calculation using the FPA to the academic system software development, FP values of object oriented model obtained for 174,64 and the FP value of structured models for 180,93. The result of function point that will be used by developers in determining the price and cost of software systems to be built. | Implementation of Function Point Analysis in Measuring The Volume
Estimation of Software System in Object Oriented and Structural Model of
Academic System | 5,752 |
This document presents the results of the Model Checking Contest held at Petri Nets 2013 in Milano. This contest aimed at a fair and experimental evaluation of the performances of model checking techniques applied to Petri nets. This is the third edition after two successful editions in 2011 and 2012. The participating tools were compared on several examinations (state space generation and evaluation of several types of formul{\ae} -- reachability, LTL, CTL for various classes of atomic propositions) run on a set of common models (Place/Transition and Symmetric Petri nets). After a short overview of the contest, this paper provides the raw results from the contest, model per model and examination per examination. An HTML version of this report is also provided (http://mcc.lip6.fr). | Model Checking Contest @ Petri Nets, Report on the 2013 edition | 5,753 |
We introduce refinement in the function-behaviour-structure framework for design, as described by John Gero, in order to deal with complexity. We do this by connecting the frameworks for the design of two models, one the refinement of the other. The result is a framework for the design of an object that supports levels of abstraction in the design. This framework can easily be extended for the design of an object on more than two levels of abstraction. | Refinement in the Function-Behaviour-Structure Framework | 5,754 |
Researchers are often on the move, say at conferences or projects meetings, and as workflows are becoming ubiquitous in the scientific process, having access to scientific workflows from a mobile device would be a significant advantage. We therefore have developed Taverna Mobile, an application for Android phones which allows browsing of existing workflows, executing them, and reviewing the results. Taverna Mobile does not aim to reproduce the full experience of building workflows in the Taverna Workbench, rather it focuses on tasks we have deemed relevant to a scientist that is not at her desk. For instance, when visiting a conference she might hear about someone's workflow, which she can quickly locate and mark for later exploration. When in the biology lab, faced with updated scientific data, the scientist can rerun her own workflow with new inputs. While commuting, she can monitor the status of a long-running job. | Taverna Mobile: Taverna workflows on Android | 5,755 |
Software testing is aimed to improve the delivered reliability of the users. Delivered reliability is the reliability of using the software after it is delivered to the users. Usually the software consists of many modules. Thus, the delivered reliability is dependent on the operational profile which specifies how the users will use these modules as well as the defect number remaining in each module. Therefore, a good testing policy should take the operational profile into account and dynamically select tested modules according to the current state of the software during the testing process. This paper discusses how to dynamically select tested modules in order to maximize delivered reliability by formulating the selection problem as a dynamic programming problem. As the testing process is performed only once, risk must be considered during the testing process, which is described by the tester's utility function in this paper. Besides, since usually the tester has no accurate estimate of the operational profile, by employing robust optimization technique, we analysis the selection problem in the worst case, given the uncertainty set of operational profile. By numerical examples, we show the necessity of maximizing delivered reliability directly and using robust optimization technique when the tester has no clear idea of the operational profile. Moreover, it is shown that the risk averse behavior of the tester has a major influence on the delivered reliability. | Robust Dynamic Selection of Tested Modules in Software Testing for
Maximizing Delivered Reliability | 5,756 |
Basic automated refactoring operations can be chained to perform complex structure transformations. This is useful for recovering the initial architecture of a source code which has been degenerated with successive evolutions during its maintenance lifetime. This is also useful for changing the structure of a program so that a maintenance task at hand becomes modular when it would be initially crosscutting. We focus on programs structured according to Composite and Visitor design patterns, which have dual properties with respect to modularity. We consider a refactoring-based round-trip transformation between these two structures and we study how that transformation is impacted by four variations in the implementation of these patterns. We validate that study by computing the smallest preconditions for the resulting transformations. We also automate the transformation and apply it to JHotDraw, where the studied variations occur. | Transformations between Composite and Visitor implementations in Java | 5,757 |
A code change pattern represents a kind of recurrent modification in software. For instance, a known code change pattern consists of the change of the conditional expression of an if statement. Previous work has identified different change patterns. Complementary to the identification and definition of change patterns, the automatic extraction of pattern instances is essential to measure their empirical importance. For example, it enables one to count and compare the number of conditional expression changes in the history of different projects. In this paper we present a novel approach for search patterns instances from software history. Our technique is based on the analysis of Abstract Syntax Trees (AST) files within a given commit. We validate our approach by counting instances of 18 change patterns in 6 open-source Java projects. | Automatically Extracting Instances of Code Change Patterns with AST
Analysis | 5,758 |
Quality managers, change agents and researchers are often troubled in defining and demonstrating the level of success achieved in software process improvement (SPI) initiatives. So far, there exist only few frameworks for identifying the level of success achieved in SPI. Analysis shows that these frameworks do not provide a comprehensive view from all relevant stakeholders involved in SPI. Early results from an ongoing research effort to discover and operationalise success dimensions are reported. Adapted from the project management literature it is suggested that five dimensions characterise the level of success achieved in SPI: (1) project efficiency, (2) impact on the process user, (3) business success, (4) direct operational success and (5) process improvement fit. Results from an empirical analysis are reported where 23 change agents evaluated the relative level of importance of each dimension. Early results indicate that change agents valued the process user satisfaction the most and the process improvement fit the least. This finding confirms the need of having various stakeholders and dimensions acknowledged in a framework that is used to measure the overall success of an SPI initiative. | Measuring the Success of Software Process Improvement: The Dimensions | 5,759 |
Open Source Software (OSS) Projects are gaining popularity worldwide. Studies by many researchers show that the important key success factor is modularity of the source code. This paper presents the revised Modularity Index which is a software metrics to measure the modularity level of a javabased OSS Projects. To show its effectiveness in analyzing OSS Project, the Modularity Index and its supporting software metrics are then used to analyze the evolution of Freemind mind mapping OSS Project. The analysis using Modularity Index and its supporting metrics shows the strength and weaknesses of the Freemind OSS Projects. | Revised Modularity Index to Measure Modularity of OSS Projects with Case
Study of Freemind | 5,760 |
Open Source Software (OSS) Projects are gaining popularity these days, and they become alternatives in building software system. Despite many failures in these projects, there are some success stories with one of the identified success factors is modularity. This paper presents the first quantitative software metrics to measure modularity level of Java-based OSS Projects called Modularity Index. This software metrics is formulated by analyzing modularity traits such as size, complexity, cohesion, and coupling of 59 Java-based OSS Projects from sourceforge.net using SONAR tool. These OSS Projects are selected since they have been downloaded more than 100K times and believed to have the required modularity trait to be successful. The software metrics related to modularity in class, package and system level of these projects are extracted and analyzed. The similarities found are then analyzed to determine the class quality, package quality, and then combined with system architecture measure to formulate the Modularity Index. The case study of measuring Modularity Index during the evolution of JFreeChart project has shown that this software metrics is able to identify strengths and potential problems of the project. | Modularity Index Metrics for Java-Based Open Source Software Projects | 5,761 |
In collaborative agile ontology development projects support for modular reuse of ontologies from large existing remote repositories, ontology project life cycle management, and transitive dependency management are important needs. The Apache Maven approach has proven its success in distributed collaborative Software Engineering by its widespread adoption. The contribution of this paper is a new design artifact called OntoMaven. OntoMaven adopts the Maven-based development methodology and adapts its concepts to knowledge engineering for Maven-based ontology development and management of ontology artifacts in distributed ontology repositories. | OntoMaven: Maven-based Ontology Development and Management of
Distributed Ontology Repositories | 5,762 |
Interfaces are recognized as an important mechanism to define contracts governing interactions between semi-independent software modules. Well-designed interfaces significantly reduce software complexity and ease maintainability by fostering modularization, hiding implementation details and minimizing the impact caused by changes in the software implementation. However, designing good interfaces is not a trivial task. The presence of interface design defects often yield increased development cost, lower code quality and reduced development productivity. Despite their importance, currently there are only a few research efforts that investigate the quality of interface design. In this paper, we identify and characterize common interface design anomalies and illustrate them via examples taken from well-known open source applications. In order to quantify the presence of interface design anomalies and estimate their impact on the interface design quality, as well on the software quality attributes, such as maintainability, we conduct an empirical study covering 9 open source projects. Building on our empirical results, we develop a set of recommendations to improve interface design. | Software Interfaces: On The Impact of Interface Design Anomalies | 5,763 |
Modelling software product line (SPL) features plays a crucial role to a successful development of SPL. Feature diagram is one of the widely used notations to model SPL variants. However, there is a lack of precisely defined formal notations for representing and verifying such models. This paper presents an approach that we adopt to model SPL variants by using UML and subsequently verify them by using first-order logic. UML provides an overall modelling view of the system. First-order logic provides a precise and rigorous interpretation of the feature diagrams. We model variants and their dependencies by using propositional connectives and build logical expressions. These expressions are then validated by the Alloy verification tool. The analysis and verification process is illustrated by using Computer Aided Dispatch (CAD) system. | Managing and Analysing Software Product Line Requirements | 5,764 |
Nowadays a vast and growing body of open source software (OSS) project data is publicly available on the internet. Despite this public body of project data, the field of software analytics has not yet settled on a solid quantitative base for basic properties such as code size, growth, team size, activity, and project failure. What is missing is a quantification of the base rates of such properties, where other fields (such as medicine) commonly rely on base rates for decision making and the evaluation of experimental results. The lack of knowledge in this area impairs both research activities in the field of software analytics and decision making on software projects in general. This paper contributes initial results of our research towards obtaining base rates using the data available at Ohloh (a large-scale index of OSS projects). Zooming in on the venerable 'lines of code' metric for code size and growth, we present and discuss summary statistics and identify further research challenges. | Towards Base Rates in Software Analytics | 5,765 |
Designing the user interface (UI) of mobile applications in the enterprise is performed in many cases by the application users who represent the business needs. This is based on existing developed enterprise services that can be accessed by these applications. Design the UI of the mobile applications require programming environments that are as much as possible codeless and easy to use. In this paper, we present NitroGen which is a cloud-based platform-independent tool that provides with no installation, a consumable integrated set of capabilities to construct mobile solutions aiming at reducing development and maintenance costs. We further illustrate how to use NitroGen showing its visual touch-based mostly codeless way of programming. NitroGen can easily connect to back-end services thus enable fast and facile development in enterprises. | Codeless Screen-Oriented Programming for Enterprise Mobile Applications | 5,766 |
The present business network infrastructure is quickly varying with latest servers, services, connections, and ports added often, at times day by day, and with a uncontrollably inflow of laptops, storage media and wireless networks. With the increasing amount of vulnerabilities and exploits coupled with the recurrent evolution of IT infrastructure, organizations at present require more numerous vulnerability assessments. In this paper new approach the Unified process for Network vulnerability Assessments hereafter called as a unified NVA is proposed for network vulnerability assessment derived from Unified Software Development Process or Unified Process, it is a popular iterative and incremental software development process framework. | The Unified Approach For Organizational Network Vulnerability Assessment | 5,767 |
This volume contains the extended abstracts of the contributions presented at EclipseIT 2013, the 8th workshop of the Italian Eclipse Community, hosted by the Computer Science Department of the University of Milan (Crema Campus) on September 19-20, 2013. Although Eclipse was initially designed as an integrated development environment (IDE) for object-oriented application development, today it represents an open development platform comprised of extensible frameworks, tools and runtimes for building, deploying and managing software. Around Eclipse, an international live community continuously works on improving the framework and on promoting the use of Eclipse. That happens also in Italy. This workshop is, indeed, the eighth yearly meeting of the Italian Eclipse Community which includes universities, public institutions and industries, researchers and practitioners, students and professionals, all joined by the interest in experimenting, extending, and supporting the Eclipse platform. The special topic of this edition is the Software cooperative development for mobile applications. Two tutorials are offered on this theme: (1) Sviluppo di applicazioni enterprise per il mobile con IBM Jazz, Eclipse e Worklight by Ferdinando Gorga from IBM, and (2) Uso di Eclipse per lo sviluppo cooperativo del software, by Paolo Maresca of the University of Naples, Federico II. | Eclipse-IT 2013: Proceedings of VIII Workshop of the Italian Eclipse
Community | 5,768 |
Software Product Lines (SPL) are inherently difficult to test due to the combinatorial explosion of the number of products to consider. To reduce the number of products to test, sampling techniques such as combinatorial interaction testing have been proposed. They usually start from a feature model and apply a coverage criterion (e.g. pairwise feature interaction or dissimilarity) to generate tractable, fault-finding, lists of configurations to be tested. Prioritization can also be used to sort/generate such lists, optimizing coverage criteria or weights assigned to features. However, current sampling/prioritization techniques barely take product behavior into account. We explore how ideas of statistical testing, based on a usage model (a Markov chain), can be used to extract configurations of interest according to the likelihood of their executions. These executions are gathered in featured transition systems, compact representation of SPL behavior. We discuss possible scenarios and give a prioritization procedure illustrated on an example. | Towards Statistical Prioritization for Software Product Lines Testing | 5,769 |
Agile software development methodologies focus on software projects which are behind schedule or highly likely to have a problematic development phase. In the last decade, Agile methods have transformed from cult techniques to mainstream methodologies. Scrum, an Agile software development method, has been widely adopted due to its adaptive nature. This paper presents a metric that measures the quality of the testing process in a Scrum process. As product quality and process quality correlate, improved test quality can ensure high quality products. Also, gaining experience from eight years of successful Scrum implementation at SoftwarePeople, we describe the Scrum process emphasizing the testing process. We propose a metric Product Backlog Rating (PBR) to assess the testing process in Scrum. PBR considers the complexity of the features to be developed in an iteration of Scrum, assesses test ratings and offers a numerical score of the testing process. This metric is able to provide a comprehensive overview of the testing process over the development cycle of a product. We present a case study which shows how the metric is used at SoftwarePeople. The case study explains some features that have been developed in a Sprint in terms of feature complexity and potential test assessment difficulties and shows how PBR is calculated during the Sprint. We propose a test process assessment metric that provides insights into the Scrum testing process. However, the metric needs further evaluation considering associated resources (e.g., quality assurance engineers, the length of the Scrum cycle). | Product Backlog Rating: A Case Study On Measuring Test Quality In Scrum | 5,770 |
TouchDevelop is a new programming environment that allows users to create applications on mobile devices. Applications created with TouchDevelop have continued to grow in popularity since TouchDevelop was first released to public in 2011. This paper presents a field study of 31,699 applications, focusing on different characteristics between 539 game scripts and all other non-game applications, as well as what make some game applications more popular than others to users. The study provides a list of findings on characteristics of game scripts and also implications for improving end-user programming of game applications. | A Preliminary Field Study of Game Programming on Mobile Devices | 5,771 |
Companies increasingly use either manual or automated system testing to ensure the quality of their software products. As a system evolves and is extended with new features the test suite also typically grows as new test cases are added. To ensure software quality throughout this process the test suite is continously executed, often on a daily basis. It seems likely that newly added tests would be more likely to fail than older tests but this has not been investigated in any detail on large-scale, industrial software systems. Also it is not clear which methods should be used to conduct such an analysis. This paper proposes three main concepts that can be used to investigate aging effects in the use and failure behavior of system test cases: test case activation curves, test case hazard curves, and test case half-life. To evaluate these concepts and the type of analysis they enable we apply them on an industrial software system containing more than one million lines of code. The data sets comes from a total of 1,620 system test cases executed a total of more than half a million times over a time period of two and a half years. For the investigated system we find that system test cases stay active as they age but really do grow old; they go through an infant mortality phase with higher failure rates which then decline over time. The test case half-life is between 5 to 12 months for the two studied data sets. | Do System Test Cases Grow Old? | 5,772 |
Effort Estimation has always been a challenging task for the Project managers. Many researchers have tried to help them by creating different types of models. This has been already proved that none is successful for all types of projects and every type of environment. Analytic Hierarchy Process has been identified as the tool that would help in Multi Criteria Decision Making. Researchers have identified that Analytic Hierarchy Process can be used for the comparison of effort estimation of different models and techniques. But the problem with traditional Analytic Hierarchy Process is its inability to deal with the imprecision and subjectivity in the pairwise comparison process. The motive of this paper is to propose Fuzzy Analytic Hierarchy Process, which can be used to rectify the subjectivity and imprecision of Analytic Hierarchy Process and can be used for selecting the type of Model best suited for estimating the effort for a given problem type or environment. Instead of single crisp value, Fuzzy Analytic Hierarchy Process uses a range of values to incorporate decision maker uncertainty. From this range, decision maker can select the value that reflects his confidence and also he can specify his attitude like optimistic, pessimistic or moderate. In this work, the comparison of Analytic Hierarchy Process and Fuzzy Analytic Hierarchy Process is concluded using a case study of selection of effort estimation model. | Multi criteria decision making approach for selecting effort estimation
model | 5,773 |
The effort invested in a software project is probably one of the most important and most analyzed variables in recent years in the process of project management. The limitation of algorithmic effort prediction models is their inability to cope with uncertainties and imprecision surrounding software projects at the early development stage. More recently attention has turned to a variety of machine learning methods, and soft computing in particular to predict software development effort. Soft computing is a consortium of methodologies centering in fuzzy logic, artificial neural networks, and evolutionary computation. It is important, to mention here, that these methodologies are complementary and synergistic, rather than competitive. They provide in one form or another flexible information processing capability for handling real life ambiguous situations. These methodologies are currently used for reliable and accurate estimate of software development effort, which has always been a challenge for both the software industry and academia. The aim of this study is to analyze soft computing techniques in the existing models and to provide in depth review of software and project estimation techniques existing in industry and literature based on the different test datasets along with their strength and weaknesses | Soft computing techniques for software effort estimation | 5,774 |
Software effort estimation requires high accuracy, but accurate estimations are difficult to achieve. Increasingly, data mining is used to improve an organization's software process quality, e. g. the accuracy of effort estimations . There are a large number of different method combination exists for software effort estimation, selecting the most suitable combination becomes the subject of research in this paper. In this study, three simple preprocessors are taken (none, norm, log) and effort is measured using COCOMO model. Then results obtained from different preprocessors are compared and norm preprocessor proves to be more accurate as compared to other preprocessors. | Effect of data preprocessing on software effort estimation | 5,775 |
Institutional collaborative systems focus on providing the fast, and secure connections to students, teaching and non-teaching staff members. Access control is more important in these types of systems because different kind of users access the system on different levels. So a proper architecture must be there for these kinds of systems, for providing an efficient and secure system. As lot of work was done in RBAC like for grouping, securing the system, ease of use, and for enterprise etc but no one apply all these concepts as a whole on institution level. So, this paper will be a step towards administrative load sharing, securing the system, and ease of use. | RBAC Architecture Design Issues in Institutions Collaborative
Environment | 5,776 |
Many of quality approaches are described in hundreds of textual pages. Manual processing of information consumes plenty of resources. In this report we present a text mining approach applied on CMMI, one well known and widely known quality approach. The text mining analysis can provide a quick overview on the scope of a quality approaches. The result of the analysis could accelerate the understanding and the selection of quality approaches. | Towards Applying Text Mining Techniques on Software Quality Standards
and Models | 5,777 |
The software engineering is a relatively new discipline compared to other sciences, since the origins of the term itself dates back to the years 1968 and 1969. At present, the market and the software industry have a significant relevance in several countries of the world; however, although Mexico is immersed in this race, has not even reached the level of success achieved in other countries in this sector. This paper presents an overview of the situation that keeps the practice of software engineering in Mexico, with emphasis on the academic realm. It shows a compilation of scientific research activity carried out in universities, as well as a brief analysis of undergraduate educational programs including the software engineering discipline . At the end, future work to be done is proposed in order to find a point of convergence between academia and industry, and also to support the flourishing of this business which somehow will have a positive impact on the economy of our country. | Estado Actual de la Práctica de la Ingeniería de Software en
México | 5,778 |
The open source development community consists of both paid and volunteer developers as well as new and experienced users. Previous work has applied social network analysis (SNA) to open source communities and has demonstrated value in expertise discovery and triaging. One problem with applying SNA directly to the data of the entire project lifetime is that the impact of local activities will be drowned out. In this paper we provide a method for aggregating, analyzing, and visualizing local (small time periods) interactions of bug reporting participants by using the SNA to measure the betweeness centrality of these participants. In particular we mined the Android bug repository by producing social networks from overlapping 30-day windows of bug reports, each sliding over by day. In this paper we define three patterns of participant behaviour based on their local centrality. We propose a method of analyzing the centrality of bug report participants both locally and globally, then we conduct a thorough case study of the bug reporter's activity within the Android bug repository. Furthermore, we validate the conclusions of our method by mining the Android version control system and inspecting the Android release history. We found that windowed SNA analysis elicited local behaviour that were invisible during global analysis. | Mining the Temporal Evolution of the Android Bug Reporting Community via
Sliding Windows | 5,779 |
Information System Quality (ISQ) management discipline requires a set of assessment mechanisms to evaluate external quality characteristics that are influenced by the environmental parameters and impacted by the ecosystem factors. The present paper suggests a new assessment oriented model that takes into consideration all facets of each external quality feature. The proposed model, named RatQual, gives a hierarchical categorization for quality. RatQual is designed to quantify dependent-environment qualities by considering internal, external and in use aspects. This model is supported by a tool that automates the assessment process. This tool gives assistance in quality evolution planning and serves for periodical monitoring operations used to enhance and improve information system quality. | Towards an Assessment-oriented Model for External Information System
Quality Characterization | 5,780 |
Emerging agile software development methods are people oriented development approaches to be used by the software industry. The personal software process (PSP) is an accepted method for improving the capabilities of a single software engineer. Five original hypotheses regarding the impact of the PSP to individual performance are tested. Data is obtained from 58 computer science students in three university courses on the master level, which were held in two different educational institutions in Finland and Denmark. Statistical data treatment shows that the use of PSP did not improve size and time estimation skills but that the productivity did not decrease and the resulting product quality was improved. The implications of these findings are briefly addressed. | Improving Software Developer's Competence: Is the Personal Software
Process Working? | 5,781 |
Software technology based on reuse is identified as a process of designing software for the reuse purpose. The software reuse is a process in which the existing software is used to build new software. A metric is a quantitative indicator of an attribute of an item or thing. Reusability is the likelihood for a segment of source code that can be used again to add new functionalities with slight or no modification. A lot of research has been projected using reusability in reducing code, domain, requirements, design etc., but very little work is reported using software reuse in medical domain. An attempt is made to bridge the gap in this direction, using the concepts of clustering and classifying the data based on the distance measures. In this paper cardiologic database is considered for study. The developed model will be useful for Doctors or Paramedics to find out the patients level in the cardiologic disease, deduce the medicines required in seconds and propose them to the patient. In order to measure the reusability K means clustering algorithm is used. | Software Reuse in Cardiology Related Medical Database Using K-Means
Clustering Technique | 5,782 |
Business processes usually do not exist as singular entities that can be managed in isolation, but rather as families of business process variants. When modelling such families of variants, analysts are confronted with the choice between modelling each variant separately, or modelling multiple or all variants in a single model. Modelling each variant separately leads to a proliferation of models that share common parts, resulting in redundancies and inconsistencies. Meanwhile, modelling all variants together leads to less but more complex models, thus hindering on comprehensibility. This paper introduces a method for modelling families of process variants that addresses this trade-off. The key tenet of the method is to alternate between steps of decomposition (breaking down processes into sub-processes) and deciding which parts should be modelled together and which ones should be modelled separately. We have applied the method to two case studies: one concerning the consolidation of ex-isting process models, and another dealing with green-field process discovery. In both cases, the method produced fewer models with respect to the baseline and reduced duplicity by up to 50% without significant impact on complexity. | Modelling Families of Business Process Variants: A Decomposition Driven
Method | 5,783 |
Highly iterative development processes such as Kanban have gained significant importance in industry. However, the impact of such processes on team collaboration and communication is widely unknown. In this paper, we analyze how the Kanban process aids software team's behaviours -- in particular, communication and collaboration. The team under study developed a mobile payment software product in six iterations over seven weeks. The data were collected by a questionnaire, repeated at the end of each iteration. The results indicate that Kanban has a positive effect at the beginning to get the team working together to identify and coordinate the work. Later phases, when the team members have established good rapport among them, the importance for facilitating team collaboration could not be shown. Results also indicate that Kanban helps team members to collectively identify and surface the missing tasks to keep the pace of the development harmonized across the whole team, resulting into increased collaboration. Besides presenting the study and the results, the article gives an outlook on future work. | How Does Kanban Impact Communication and Collaboration in Software
Engineering Teams? | 5,784 |
Nowadays, many software projects are partially or completely open-source based. There is an increasing need for companies to participate in open-source software (OSS) projects, e.g., in order to benefit from open source ecosystems. OSS projects introduce particular challenges that have to be understood in order to gain the benefits. One such challenge is getting newcomers onboard into the projects effectively. Similar challenges may be present in other self-organised, virtual team environments. In this paper we present preliminary observations and results of in-progress research that studies the process of onboarding into virtual OSS teams. The study is based on a program created and conceived at Stanford University in conjunction with Facebook's Education Modernization program. It involves the collaboration of more than a dozen international universities and nine open source projects. More than 120 students participated in 2013. The students have been introduced to and supported by mentors experienced in the participating OSS projects. Our findings indicate that mentoring is an important factor for effective onboarding in OSS projects, promoting cohesion within distributed teams and maintaining an appropriate pace. | Onboarding in Open Source Software Projects: A Preliminary Analysis | 5,785 |
Many product lines are critical, and therefore reliability is a vital part of their requirements. Reliability is a probabilistic property. We therefore propose a model for feature-aware discrete-time Markov chains as a basis for verifying probabilistic properties of product lines, including reliability. We compare three verification techniques: The enumerative technique uses PRISM, a state-of-the-art symbolic probabilistic model checker, on each product. The parametric technique exploits our recent advances in parametric model checking. Finally, we propose a new bounded technique that performs a single bounded verification for the whole product line, and thus takes advantage of the common behaviours of the product line. Experimental results confirm the advantages of the last two techniques. | Verification for Reliable Product Lines | 5,786 |
Aligning software-related activities with corporate strategies and goals is increasingly important for several reasons such as increasing the customer satisfaction in software-based products and services. Several approaches have been proposed to create such an alignment. GQM+Strategies is an approach that applies measurement principles to link goals and strategies on different levels of an organisation. In this paper, we describe experiences from applying GQM+Strategies to elicit, link, and align the goals of an integrated systems product development organisation across multiple organisational levels. We provide insights into how GQM+Strategies was applied during a five- month period. The paper presents the enacted application process and main lessons learnt. In addition, related approaches are described and an outlook on future work is given. | Experiences and Insights from Applying GQM+Strategies in a Systems
Product Development Organisation | 5,787 |
The allocation of tasks can be seen as a success-critical management activity in distributed development projects. However, such task allocation is still one of the major challenges in global software development due to an insufficient understanding of the criteria that influence task allocation decisions. This article presents a qualitative study aimed at identifying and understanding such criteria that are used in practice. Based on interviews with managers from selected software development organizations, criteria currently applied in industry are identified. One important result is, for instance, that the sourcing strategy and the type of software to be developed have a significant effect on the applied criteria. The article presents the goals, design, and results of the study as well as an overview of related and future work. | A Survey on the State of the Practice in Distributed Software
Development: Criteria for Task Allocation | 5,788 |
During the life cycle of software development, developers have to fix different kinds of bugs reported by testers or end users. The efficiency and effectiveness of fixing bugs have a huge impact on the reliability of the software as well as the productivity of the development team. Software companies usually spend a large amount of money and human resources on the testing and bug fixing departments. As a result, a better and more reliable way to fix bugs is highly desired by them. In order to achieve such goal, in depth studies on the characteristics of bug fixes from well maintained, highly popular software projects are necessary. In this paper, we study the bug fixing histories extracted from the Eclipse project, a well maintained, highly popular open source project. After analyzing more than 36,000 bugs that belongs to three major kinds of exception types, we are able to reveal some common fix types that are frequently used to fix certain kinds of program exceptions. Our analysis shows that almost all of the exceptions that belong to a certain exception can be fixed by less than ten fix types. Our result implies that most of the bugs in software projects can be and should be fixed by only a few common fix patterns. | Mining Crash Fix Patterns | 5,789 |
PLOS and Mozilla conducted a month-long pilot study in which professional developers performed code reviews on software associated with papers published in PLOS Computational Biology. While the developers felt the reviews were limited by (a) lack of familiarity with the domain and (b) lack of two-way contact with authors, the scientists appreciated the reviews, and both sides were enthusiastic about repeating the experiment. | PLOS/Mozilla Scientific Code Review Pilot: Summary of Findings | 5,790 |
Web Services provide interoperable mechanisms for describing, locating and invoking services over the Internet; composition further enables to build complex services out of simpler ones for complex B2B applications. While current studies on these topics are mostly focused - from the technical viewpoint - on standards and protocols, this paper investigates the adoption of formal methods, especially for composition. We logically classify and analyze three different (but interconnected) kinds of important issues towards this goal, namely foundations, verification and extensions. The aim of this work is to individuate the proper questions on the adoption of formal methods for dependable composition of Web Services, not necessarily to find the optimal answers. Nevertheless, we still try to propose some tentative answers based on our proposal for a composition calculus, which we hope can animate a proper discussion. | Issues about the Adoption of Formal Methods for Dependable Composition
of Web Services | 5,791 |
Enterprise Resource Planning ERP systems integrate information across an entire organization that automate core activities such as finance accounting, human resources, manufacturing, production and supply chain management etc. to facilitate an integrated centralized system and rapid decision making resulting in cost reduction, greater planning, and increased control. Many organizations are updating their current management information systems with ERP systems. This is not a trivial task. They have to identify the organizations objectives and satisfy a myriad of stakeholders. They have to understand what business processes they have, how they can be improved, and what particular systems would best suit their needs. They have to understand how an ERP system is built, it involves the modification of an existing system with its own set of business rules. Deciding what to ask for and how to select the best option is a very complex operation and there is limited experience with this type of contracting in organizations. In this paper we discuss a particular experience with contracting out an ERP system, provide some lessons learned, and offer suggestions in how the RFP and bid selection processes could have been improved. | An Experience based Evaluation Process for ERP bids | 5,792 |
Popular process models such as the Rational Unified Process or the V-Modell XT are by nature large and complex. Each time that a new release is published software development organizations are confronted with the big challenge of understanding the rationale behind the new release and the extent to which it affects them. Usually, there is no information about what has changed or most importantly why. This is because of the lack of a flexible approach that supports organizations responsible for evolving such large process models in documenting their decisions and that reflects the extent of the capabilities to which they can provide this information. This paper describes an approach to incrementally deploying rationale support as needed to match an organisation's needs, the capabilities and interests of the organisation's process engineering teams, and the organisation's willingness to support the effort required for the collection and application of the rationale information. | Incrementally Introducing Process Model Rationale Support in an
Organization | 5,793 |
System reuse and cost are very important in software product line design area. Developers goal is to increase system reuse and decreasing cost and efforts for building components from scratch for each software configuration. This can be reached by developing Software Product Line (SPL). To handle SPL engineering process, several approaches with several techniques were developed. One of these approaches is called separated approach. It requires separating the commonalities and variability for system components to allow configuration selection based on user defined features. Textual notation-based approaches have been used for their formal syntax and semantics to represent system features and implementations. But these approaches are still weak in mixing features (conceptual level) and classes (physical level) that guarantee smooth and automatic configuration generation for software releases. The absence of methodology supporting the mixing process is a real weakness. In this paper, we enhanced SPL reuse by introducing some meta-features, classified according to their functions. As a first consequence, mixing class and feature concepts is supported in a simple way using class interfaces and inherent features for smooth move from feature model to class model. And as a second consequence, the mixing process is supported by a textual design and implementation methodology, mixing class and feature models by combining their concepts in a single language. The supported configuration generation process is simple, coherent, and complete. | Systems Variability Modeling: A Textual Model Mixing Class and Feature
Concepts | 5,794 |
This paper is about understanding the nature of bug fixing by analyzing thousands of bug fix transactions of software repositories. It then places this learned knowledge in the context of automated program repair. We give extensive empirical results on the nature of human bug fixes at a large scale and a fine granularity with abstract syntax tree differencing. We set up mathematical reasoning on the search space of automated repair and the time to navigate through it. By applying our method on 14 repositories of Java software and 89,993 versioning transactions, we show that not all probabilistic repair models are equivalent. | Mining Software Repair Models for Reasoning on the Search Space of
Automated Program Fixing | 5,795 |
This technical report discusses the submission and peer-review process used by the First Workshop on on Sustainable Software for Science: Practice and Experiences (WSSSPE) and the results of that process. It is intended to record both this alternative model as well as the papers associated with the workshop that resulted from that process. | First Workshop on Sustainable Software for Science: Practice and
Experiences (WSSSPE): Submission and Peer-Review Process, and Results | 5,796 |
The cutting edge in systems development today is in the area of "systems of systems" (SoS) large networks of inter-related systems that are developed and managed separately, but that also perform collective activities. Such large systems typically involve constituent systems operating with different life cycles, often with uncoordinated evolution. The result is an ever-changing SoS in which adaptation and evolution replace the older engineering paradigm of "development". This short paper presents key thoughts about verification and validation in this environment. Classic verification and validation methods rely on having (a) a basis of proof, in requirements and in operational scenarios, and (b) a known system configuration to be proven. However, with constant SoS evolution, management of both requirements and system configurations are problematic. Often, it is impossible to maintain a valid set of requirements for the SoS due to the ongoing changes in the constituent systems. Frequently, it is even difficult to maintain a vision of the SoS operational use as users find new ways to adapt the SoS. These features of the SoS result in significant challenges for system proof. In addition to discussing the issues, the paper also indicates some of the solutions that are currently used to prove the SoS. | Verification and Validation Issues in Systems of Systems | 5,797 |
In this position paper (1) we discuss two particular aspects of Systems of Systems, i.e., variability and evolution. (2) We argue that concepts from Product Line Engineering and Software Evolution are relevant to Systems of Systems Engineering. (3) Conversely, concepts from Systems of Systems Engineering can be helpful in Product Line Engineering and Software Evolution. Hence, we argue that an exchange of concepts between the disciplines would be beneficial. | Variability and Evolution in Systems of Systems | 5,798 |
The paper presents an explicit state-based modeling approach aimed at modeling Systems of Systems behavior. The approach allows to specify and verify incrementally safety and liveness rules without using model checking techniques. The state-based approach allows moreover to use the system behavior directly as an interface, greatly improving the effectiveness of the recursive composition needed when assembling Systems of Systems. Such systems are, at the same time, both parts and wholes, thus giving a formal characterization to the notion of Holon. | Systems of Systems Modeled by a Hierarchical Part-Whole State-Based
Formalism | 5,799 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.