Elysium Technologies Private Limited Singapore | Madurai | Chennai | Trichy | Coimbatore | Cochin | Ramnad | Pondicherry | Trivandrum | Salem | Erode | Tirunelveli http://www.elysiumtechnologies.com , [email protected]13 Years of Experience Automated Services 24/7 Help Desk Support Experience & Expertise Developers Advanced Technologies & Tools Legitimate Member of all Journals Having 1,50,000 Successive records in all Languages More than 12 Branches in Tamilnadu, Kerala & Karnataka. Ticketing & Appointment Systems. Individual Care for every Student. Around 250 Developers & 20 Researchers
19
Embed
Final Year IEEE Project 2013-2014 - Software Engineering Project Title and Abstract
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Pondicherry | Trivandrum | Salem | Erode | Tirunelveli
http://www.elysiumtechnologies.com, [email protected] advice to builders of software engineering tools. Although hypotheses are important in debugging, a
theory of navigation adds more practical value to our understanding of how programmers debug.
Therefore, in this paper, we reconsider how people go about debugging in large collections of source code
using a modern programming environment. We present an information foraging theory of debugging that
treats programmer navigation during debugging as being analogous to a predator following scent to find
prey in the wild. The theory proposes that constructs of scent and topology provide enough information to
describe and predict programmer navigation during debugging, without reference to mental states such as
hypotheses. We investigate the scope of our theory through an empirical study of 10 professional
programmers debugging a real-world open source program. We found that the programmers'
verbalizations far more often concerned scent-following than hypotheses. To evaluate the predictiveness
of our theory, we created an executable model that predicted programmer navigation behavior more
accurately than comparable models that did not consider information scent. Finally, we discuss the
implications of our results for enhancing software engineering tools
ETPL
SE-004
Empirical Principles and an Industrial Case Study in Retrieving Equivalent
Requirements via Natural Language Processing Techniques
Abstract: Though very important in software engineering, linking artifacts of the same type (clone
detection) or different types (traceability recovery) is extremely tedious, error-prone, and effort-intensive.
Past research focused on supporting analysts with techniques based on Natural Language Processing
(NLP) to identify candidate links. Because many NLP techniques exist and their performance varies
according to context, it is crucial to define and use reliable evaluation procedures. The aim of this paper is
to propose a set of seven principles for evaluating the performance of NLP techniques in identifying
equivalent requirements. In this paper, we conjecture, and verify, that NLP techniques perform on a given
dataset according to both ability and the odds of identifying equivalent requirements correctly. For
instance, when the odds of identifying equivalent requirements are very high, then it is reasonable to
expect that NLP techniques will result in good performance. Our key idea is to measure this random
factor of the specific dataset(s) in use and then adjust the observed performance accordingly. To support
the application of the principles we report their practical application to a case study that evaluates the
performance of a large number of NLP techniques for identifying equivalent requirements in the context
of an Italian company in the defense and aerospace domain. The current application context is the
evaluation of NLP techniques to identify equivalent requirements. However, most of the proposed
principles seem applicable to evaluating any estimation technique aimed at supporting a binary decision
(e.g., equivalent/nonequivalent), with the estimate in the range [0,1] (e.g., the similarity provided by the
NLP), when the dataset(s) is used as a benchmark (i.e., testbed), independently of the type of estimator
(i.e., requirements text) and of the estimation method (e.g., NLP).
ETPL
SE-005
Assessing the Effectiveness of Sequence Diagrams in the Comprehension of Functional
Requirements: Results from a Family of Five Experiments
Abstract: Modeling is a fundamental activity within the requirements engineering process and concerns
the construction of abstract descriptions of requirements that are amenable to interpretation and
Pondicherry | Trivandrum | Salem | Erode | Tirunelveli
http://www.elysiumtechnologies.com, [email protected] validation. The choice of a modeling technique is critical whenever it is necessary to discuss the
interpretation and validation of requirements. This is particularly true in the case of functional
requirements and stakeholders with divergent goals and different backgrounds and experience. This paper
presents the results of a family of experiments conducted with students and professionals to investigate
whether the comprehension of functional requirements is influenced by the use of dynamic models that
are represented by means of the UML sequence diagrams. The family contains five experiments
performed in different locations and with 112 participants of different abilities and levels of experience
with UML. The results show that sequence diagrams improve the comprehension of the modeled
functional requirements in the case of high ability and more experienced participants.
ETPL
SE-006 Using Dependency Structures for Prioritization of Functional Test Suites
Abstract: Test case prioritization is the process of ordering the execution of test cases to achieve a certain
goal, such as increasing the rate of fault detection. Increasing the rate of fault detection can provide earlier
feedback to system developers, improving fault fixing activity and, ultimately, software delivery. Many
existing test case prioritization techniques consider that tests can be run in any order. However, due to
functional dependencies that may exist between some test cases-that is, one test case must be executed
before another-this is often not the case. In this paper, we present a family of test case prioritization
techniques that use the dependency information from a test suite to prioritize that test suite. The nature of
the techniques preserves the dependencies in the test ordering. The hypothesis of this work is that
dependencies between tests are representative of interactions in the system under test, and executing
complex interactions earlier is likely to increase the fault detection rate, compared to arbitrary test
orderings. Empirical evaluations on six systems built toward industry use demonstrate that these
techniques increase the rate of fault detection compared to the rates achieved by the untreated order,
random orders, and test suites ordered using existing "coarse-grained” techniques based on function
coverage.
ETPL
SE-007
A Second Replicated Quantitative Analysis of Fault Distributions in Complex Software
Systems
Abstract: Background: Software engineering is searching for general principles that apply across contexts,
for example, to help guide software quality assurance. Fenton and Ohlsson presented such observations
on fault distributions, which have been replicated once. Objectives: We aimed to replicate their study
again to assess the robustness of the findings in a new environment, five years later. Method: We
conducted a literal replication, collecting defect data from five consecutive releases of a large software
system in the telecommunications domain, and conducted the same analysis as in the original study.
Results: The replication confirms results on unevenly distributed faults over modules, and that fault
proneness distributions persist over test phases. Size measures are not useful as predictors of fault
proneness, while fault densities are of the same order of magnitude across releases and contexts.
Conclusions: This replication confirms that the uneven distribution of defects motivates uneven
distribution of quality assurance efforts, although predictors for such distribution of efforts are not
Pondicherry | Trivandrum | Salem | Erode | Tirunelveli
http://www.elysiumtechnologies.com, [email protected] human resource allocation to simplify the model. To develop a flexible and effective model for software
project planning, this paper develops a novel approach with an event-based scheduler (EBS) and an ant
colony optimization (ACO) algorithm. The proposed approach represents a plan by a task list and a
planned employee allocation matrix. In this way, both the issues of task scheduling and employee
allocation can be taken into account. In the EBS, the beginning time of the project, the time when
resources are released from finished tasks, and the time when employees join or leave the project are
regarded as events. The basic idea of the EBS is to adjust the allocation of employees at events and keep
the allocation unchanged at nonevents. With this strategy, the proposed method enables the modeling of
resource conflict and task preemption and preserves the flexibility in human resource allocation. To solve
the planning problem, an ACO algorithm is further designed. Experimental results on 83 instances
demonstrate that the proposed method is very promising.
ETPL
SE-011
Coordination Breakdowns and Their Impact on Development Productivity and
Software Failures
Abstract: The success of software development projects depends on carefully coordinating the effort of
many individuals across the multiple stages of the development process. In software engineering,
modularization is the traditional technique intended to reduce the interdependencies among modules that
constitute a system. Reducing technical dependencies, the theory argues, results in a reduction of work
dependencies between teams developing interdependent modules. Although that research stream has been
quite influential, it considers a static view of the problem of coordination in engineering activities.
Building on a dynamic view of coordination, we studied the relationship between socio-technical
congruence and software quality and development productivity. In order to investigate the generality of
our findings, our analyses were performed on two large-scale projects from two companies with distinct
characteristics in terms of product and process maturity. Our results revealed that the gaps between
coordination requirements and the actual coordination activities carried out by the developers
significantly increased software failures. Our analyses also showed that higher levels of congruence are
associated with improved development productivity. Finally, our results showed the congruence between
dependencies and coordinative actions is critical both in mature development settings as well as in novel
and dynamic development contexts.
ETPL
SE-012 Amorphous Slicing of Extended Finite State Machines
Abstract: Slicing is useful for many software engineering applications and has been widely studied for
three decades, but there has been comparatively little work on slicing extended finite state machines
(EFSMs). This paper introduces a set of dependence-based EFSM slicing algorithms and an
accompanying tool. We demonstrate that our algorithms are suitable for dependence-based slicing. We
use our tool to conduct experiments on 10 EFSMs, including benchmarks and industrial EFSMs. Ours is
the first empirical study of dependence-based program slicing for EFSMs. Compared to the only
previously published dependence-based algorithm, our average slice is smaller 40 percent of the time and
larger only 10 percent of the time, with an average slice size of 35 percent for termination insensitive
Pondicherry | Trivandrum | Salem | Erode | Tirunelveli
http://www.elysiumtechnologies.com, [email protected] validity of log-based failure analysis. This paper analyzes the limitations of current logging mechanisms
and proposes a rule-based approach to make logs effective to analyze software failures. The approach
leverages artifacts produced at system design time and puts forth a set of rules to formalize the placement
of the logging instructions within the source code. The validity of the approach, with respect to traditional
logging mechanisms, is shown by means of around 12,500 software fault injection experiments into real-
world systems.
ETPL
SE-021 Local versus Global Lessons for Defect Prediction and Effort Estimation
Abstract: Existing research is unclear on how to generate lessons learned for defect prediction and effort
estimation. Should we seek lessons that are global to multiple projects or just local to particular projects?
This paper aims to comparatively evaluate local versus global lessons learned for effort estimation and
defect prediction. We applied automated clustering tools to effort and defect datasets from the PROMISE
repository. Rule learners generated lessons learned from all the data, from local projects, or just from each
cluster. The results indicate that the lessons learned after combining small parts of different data sources
(i.e., the clusters) were superior to either generalizations formed over all the data or local lessons formed
from particular projects. We conclude that when researchers attempt to draw lessons from some historical
data source, they should 1) ignore any existing local divisions into multiple sources, 2) cluster across all
available data, then 3) restrict the learning of lessons to the clusters from other sources that are nearest to
the test data.
ETPL
SE-022 Centroidal Voronoi Tessellations- A New Approach to Random Testing
Abstract: Although Random Testing (RT) is low cost and straightforward, its effectiveness is not
satisfactory. To increase the effectiveness of RT, researchers have developed Adaptive Random Testing
(ART) and Quasi-Random Testing (QRT) methods which attempt to maximize the test case coverage of
the input domain. This paper proposes the use of Centroidal Voronoi Tessellations (CVT) to address this
problem. Accordingly, a test case generation method, namely, Random Border CVT (RBCVT), is
proposed which can enhance the previous RT methods to improve their coverage of the input space. The
generated test cases by the other methods act as the input to the RBCVT algorithm and the output is an
improved set of test cases. Therefore, RBCVT is not an independent method and is considered as an add-
on to the previous methods. An extensive simulation study and a mutant-based software testing
investigation have been performed to demonstrate the effectiveness of RBCVT against the ART and QRT
methods. Results from the experimental frameworks demonstrate that RBCVT outperforms previous
methods. In addition, a novel search algorithm has been incorporated into RBCVT reducing the order of
computational complexity of the new approach. To further analyze the RBCVT method, randomness
analysis was undertaken demonstrating that RBCVT has the same characteristics as ART methods in this
Pondicherry | Trivandrum | Salem | Erode | Tirunelveli
http://www.elysiumtechnologies.com, [email protected] multiple applications on a single platform. We propose a compositional approach to formal specification
and schedulability analysis of real-time applications running under a Time Division Multiplexing (TDM)
global scheduler and preemptive Fixed Priority (FP) local schedulers, according to the ARINC-653
standard. As a characterizing trait, each application is made of periodic, sporadic, and jittering tasks with
offsets, jitters, and nondeterministic execution times, encompassing intra-application synchronizations
through semaphores and mailboxes and interapplication communications among periodic tasks through
message passing. The approach leverages the assumption of a TDM partitioning to enable compositional
design and analysis based on the model of preemptive Time Petri Nets (pTPNs), which is expressly
extended with a concept of Required Interface (RI) that specifies the embedding environment of an
application through sequencing and timing constraints. This enables exact verification of intra-application
constraints and approximate but safe verification of interapplication constraints. Experimentation
illustrates results and validates their applicability on two challenging workloads in the field of safety-
critical avionic systems.
ETPL
SE-026
Language-Independent and Automated Software Composition: The FeatureHouse
Experience
Abstract: Superimposition is a composition technique that has been applied successfully in many areas of
software development. Although superimposition is a general-purpose concept, it has been (re)invented
and implemented individually for various kinds of software artifacts. We unify languages and tools that
rely on superimposition by using the language-independent model of feature structure trees (FSTs). On
the basis of the FST model, we propose a general approach to the composition of software artifacts
written in different languages. Furthermore, we offer a supporting framework and tool chain, called
FEATUREHOUSE. We use attribute grammars to automate the integration of additional languages. In
particular, we have integrated Java, C#, C, Haskell, Alloy, and JavaCC. A substantial number of case
studies demonstrate the practicality and scalability of our approach and reveal insights into the properties
that a language must have in order to be ready for superimposition. We discuss perspectives of our
approach and demonstrate how we extended FEATUREHOUSE with support for XML languages (in
particular, XHTML, XMI/UML, and Ant) and alternative composition approaches (in particular, aspect
weaving). Rounding off our previous work, we provide here a holistic view of the FEATUREHOUSE
approach based on rich experience with numerous languages and case studies and reflections on several
years of research.
ETPL
SE-027 A Machine Learning Approach to Software Requirements Prioritization
Abstract: Deciding which, among a set of requirements, are to be considered first and in which order is a
strategic process in software development. This task is commonly referred to as requirements
prioritization. This paper describes a requirements prioritization method called Case-Based Ranking
(CBRank), which combines project's stakeholders preferences with requirements ordering approximations
computed through machine learning techniques, bringing promising advantages. First, the human effort to
input preference information can be reduced, while preserving the accuracy of the final ranking estimates.
Second, domain knowledge encoded as partial order relations defined over the requirement attributes can
Pondicherry | Trivandrum | Salem | Erode | Tirunelveli
http://www.elysiumtechnologies.com, [email protected] be exploited, thus supporting an adaptive elicitation process. The techniques CBRank rests on and the
associated prioritization process are detailed. Empirical evaluations of properties of CBRank are
performed on simulated data and compared with a state-of-the-art prioritization method, providing
evidence of the method ability to support the management of the tradeoff between elicitation effort and
ranking accuracy and to exploit domain knowledge. A case study on a real software project complements
these experimental measurements. Finally, a positioning of CBRank with respect to state-of-the-art
requirements prioritization methods is proposed, together with a discussion of benefits and limits of the
method.
ETPL
SE-028
The Effects of Test-Driven Development on External Quality and Productivity: A
Meta-Analysis
Abstract: This paper provides a systematic meta-analysis of 27 studies that investigate the impact of Test-
Driven Development (TDD) on external code quality and productivity. The results indicate that, in
general, TDD has a small positive effect on quality but little to no discernible effect on productivity.
However, subgroup analysis has found both the quality improvement and the productivity drop to be
much larger in industrial studies in comparison with academic studies. A larger drop of productivity was
found in studies where the difference in test effort between the TDD and the control group's process was
significant. A larger improvement in quality was also found in the academic studies when the difference
in test effort is substantial; however, no conclusion could be derived regarding the industrial studies due
to the lack of data. Finally, the influence of developer experience and task size as moderator variables was
investigated, and a statistically significant positive correlation was found between task size and the
magnitude of the improvement in quality.
ETPL
SE-029 Verifying Linearizability via Optimized Refinement Checking
Abstract: Linearizability is an important correctness criterion for implementations of concurrent objects.
Automatic checking of linearizability is challenging because it requires checking that: 1) All executions
of concurrent operations are serializable, and 2) the serialized executions are correct with respect to the
sequential semantics. In this work, we describe a method to automatically check linearizability based on
refinement relations from abstract specifications to concrete implementations. The method does not
require that linearization points in the implementations be given, which is often difficult or impossible.
However, the method takes advantage of linearization points if they are given. The method is based on
refinement checking of finite-state systems specified as concurrent processes with shared variables. To
tackle state space explosion, we develop and apply symmetry reduction, dynamic partial order reduction,
and a combination of both for refinement checking. We have built the method into the PAT model
checker, and used PAT to automatically check a variety of implementations of concurrent objects,
including the first algorithm for scalable nonzero indicators. Our system is able to find all known and
Pondicherry | Trivandrum | Salem | Erode | Tirunelveli
http://www.elysiumtechnologies.com, [email protected] Bayes classifier. Furthermore, it is found that the aspects of comprehensibility and predictive performance
need to be balanced out, and also the development context is an item which should be taken into account
during model selection.
ETPL
SE-033 On Fault Representativeness of Software Fault Injection
Abstract: The injection of software faults in software components to assess the impact of these faults on
other components or on the system as a whole, allowing the evaluation of fault tolerance, is relatively new
compared to decades of research on hardware fault injection. This paper presents an extensive
experimental study (more than 3.8 million individual experiments in three real systems) to evaluate the
representativeness of faults injected by a state-of-the-art approach (G-SWFIT). Results show that a
significant share (up to 72 percent) of injected faults cannot be considered representative of residual
software faults as they are consistently detected by regression tests, and that the representativeness of
injected faults is affected by the fault location within the system, resulting in different distributions of
representative/nonrepresentative faults across files and functions. Therefore, we propose a new approach
to refine the faultload by removing faults that are not representative of residual software faults. This
filtering is essential to assure meaningful results and to reduce the cost (in terms of number of faults) of
software fault injection campaigns in complex software. The proposed approach is based on classification
algorithms, is fully automatic, and can be used for improving fault representativeness of existing software
fault injection approaches.
ETPL
SE-034
A Decentralized Self-Adaptation Mechanism for Service-Based Applications in the
Cloud
Abstract: Cloud computing, with its promise of (almost) unlimited computation, storage, and bandwidth,
is increasingly becoming the infrastructure of choice for many organizations. As cloud offerings mature,
service-based applications need to dynamically recompose themselves to self-adapt to changing QoS
requirements. In this paper, we present a decentralized mechanism for such self-adaptation, using market-
based heuristics. We use a continuous double-auction to allow applications to decide which services to
choose, among the many on offer. We view an application as a multi-agent system and the cloud as a
marketplace where many such applications self-adapt. We show through a simulation study that our
mechanism is effective for the individual application as well as from the collective perspective of all
applications adapting at the same time.
ETPL
SE-035 Coverage Estimation in Model Checking with Bitstate Hashing
Abstract: Explicit-state model checking which is conducted by state space search has difficulty in
exploring satisfactory state space because of its memory requirements. Though bitstate hashing achieves
memory efficiency, it cannot guarantee complete verification. Thus, it is desirable to provide a reliability
indicator such as a coverage estimate. However, the existing approaches for coverage estimation are not
very accurate when a verification run covers a small portion of state space. This mainly stems from the
Pondicherry | Trivandrum | Salem | Erode | Tirunelveli
http://www.elysiumtechnologies.com, [email protected] lack of information that reflects characteristics of models. Therefore, we propose coverage estimation
methods using a growth curve that approximates an increase in reached states by enlarging a bloom filter.
Our approaches improve estimation accuracy by leveraging the statistics from multiple verification runs.
Coverage is estimated by fitting the growth curve to these statistics. Experimental results confirm the
validity of the proposed growth curve and the applicability of our approaches to practical models. In fact,
for practical models, our approaches outperformed the conventional ones when the actual coverage is
relatively low.
ETPL
SE-036 Synthesizing Modal Transition Systems from Triggered Scenarios
Abstract: Synthesis of operational behavior models from scenario-based specifications has been
extensively studied. The focus has been mainly on either existential or universal interpretations. One
noteworthy exception is Live Sequence Charts (LSCs), which provides expressive constructs for
conditional universal scenarios and some limited support for nonconditional existential scenarios. In this
paper, we propose a scenario-based language that supports both existential and universal interpretations
for conditional scenarios. Existing model synthesis techniques use traditional two-valued behavior
models, such as Labeled Transition Systems. These are not sufficiently expressive to accommodate
specification languages with both existential and universal scenarios. We therefore shift the target of
synthesis to Modal Transition Systems (MTS), an extension of labeled Transition Systems that can
distinguish between required, unknown, and proscribed behavior to capture the semantics of existential
and universal scenarios. Modal Transition Systems support elaboration of behavior models through
refinement, which complements an incremental elicitation process suitable for specifying behavior with
scenario-based notations. The synthesis algorithm that we define constructs a Modal Transition System
that uses refinement to characterize all the Labeled Transition Systems models that satisfy a mixed,
conditional existential and universal scenario-based specification. We show how this combination of
scenario language, synthesis, and Modal Transition Systems supports behavior model elaboration.
ETPL
SE-037 Proactive and Reactive Runtime Service Discovery: A Framework and Its Evaluation
Abstract: The identification of services during the execution of service-based applications to replace
services in them that are no longer available and/or fail to satisfy certain requirements is an important
issue. In this paper, we present a framework to support runtime service discovery. This framework can
execute service discovery queries in pull and push mode. In pull mode, it executes queries when a need
for finding a replacement service arises. In push mode, queries are subscribed to the framework to be
executed proactively and, in parallel with the operation of the application, to identify adequate services
that could be used if the need for replacing a service arises. Hence, the proactive (push) mode of query
execution makes it more likely to avoid interruptions in the operation of service-based applications when
a service in them needs to be replaced at runtime. In both modes of query execution, the identification of
services relies on distance-based matching of structural, behavioral, quality, and contextual characteristics
of services and applications. A prototype implementation of the framework has been developed and an