Software eng

Elysium Technologies Private Limited
ISO 9001:2008 A leading Research and Development Division
Madurai | Chennai | Trichy | Coimbatore | Kollam| Singapore
Website: elysiumtechnologies.com, elysiumtechnologies.info
Email: info@elysiumtechnologies.com

IEEE Final Year Project List 2011-2012

Abstract SOFTWARE ENGINEERING 2011 - 2012

01 A Controlled Experiment for Program Comprehension through Trace Visualization

Software maintenance activities require a sufficient level of understanding of the software at hand that unfortunately is not
always readily available. Execution trace visualization is a common approach in gaining this understanding, and among our
own efforts in this context is EXTRAVIS, a tool for the visualization of large traces. While many such tools have been
evaluated through case studies, there have been no quantitative evaluations to the present day. This paper reports on the
first controlled experiment to quantitatively measure the added value of trace visualization for program comprehension. We
designed eight typical tasks aimed at gaining an understanding of a representative subject system, and measured how a
control group (using the Eclipse IDE) and an experimental group (using both Eclipse and EXTRAVIS) performed these tasks
in terms of time spent and solution correctness.

Madurai Trichy Kollam
Elysium Technologies Private Limited Elysium Technologies Private Limited Elysium Technologies Private Limited
230, Church Road, Annanagar, 3rd Floor,SI Towers, Surya Complex,Vendor junction,
Madurai , Tamilnadu – 625 020. 15 ,Melapudur , Trichy, kollam,Kerala – 691 010.
Contact : 91452 4390702, 4392702, 4394702. Tamilnadu – 620 001. Contact : 91474 2723622.
eMail: info@elysiumtechnologies.com Contact : 91431 - 4002234. eMail: elysium.kollam@gmail.com
eMail: elysium.trichy@gmail.com
1



02 A General Software Defect-Proneness Prediction Framework

BACKGROUND—Predicting defect-prone software components is an economically important activity and so has received a
good deal of attention. However, making sense of the many, and sometimes seemingly inconsistent, results is difficult.
OBJECTIVE—We propose and evaluate a general framework for software defect prediction that supports 1) unbiased and 2)
comprehensive comparison between competing prediction systems. METHOD—The framework is comprised of 1) scheme
evaluation and 2) defect prediction components. The scheme evaluation analyzes the prediction performance of competing
learning schemes for given historical data sets. The defect predictor builds models according to the evaluated learning
scheme and predicts software defects with new data according to the constructed model. In order to demonstrate the
performance of the proposed framework, we use both simulation and publicly available software defect data sets.

03 An Attack Surface Metric

2



Measurement of software security is a long-standing challenge to the research community. At the same time, practical
security metrics and measurements are essential for secure software development. Hence, the need for metrics is more
pressing now due to a growing demand for secure software. In this paper, we propose using a software system’s attack
surface measurement as an indicator of the system’s security. We formalize the notion of a system’s attack surface and
introduce an attack surface metric to measure the attack surface in a systematic manner. Our measurement method is
agnostic to a software system’s implementation language and is applicable to systems of all sizes; we demonstrate our
method by measuring the attack surfaces of small desktop applications and large enterprise systems implemented in C and
Java.

04 Assessing, Comparing, and Combining State Machine-Based Testing and Structural Testing: A Series of Experiments

A large number of research works have addressed the importance of models in software engineering. However, the
adoption of model-based techniques in software organizations is limited since these models are perceived to be expensive
and not necessarily cost-effective. Focusing on model-based testing, this paper reports on a series of controlled
experiments. It investigates the impact of state machine testing on fault detection in class clusters and its cost when

3


compared with structural testing. Based on previous work showing this is a good compromise in terms of cost and
effectiveness, this paper focuses on a specific state-based technique: the round-trip paths coverage criterion. Round-trip
paths testing are compared to structural testing, and it is investigated whether they are complementary.

05 Automatically detecting and tracking inconsistence in software design Model

Software models typically contain many inconsistencies and consistency checkers help engineers find them. Even if
engineers are willing to tolerate inconsistencies, they are better off knowing about their existence to avoid follow-on errors
and unnecessary rework. However, current approaches do not detect or track inconsistencies fast enough. This paper
presents an automated approach for detecting and tracking inconsistencies in real time (while the model changes).
Engineers only need to define consistency rules—in any language—and our approach automatically identifies how model
changes affect these consistency rules. It does this by observing the behavior of consistency rules to understand how they
affect the model. The approach is quick, correct, scalable, fully automated, and easy to use as it does not require any special
skills from the engineers using it.

4



06 Deriving a Slicing Algorithm via FermaT Transformations

In this paper, we present a case study in deriving an algorithm from a formal specification via FermaT transformations. The
general method (which is presented in a separate paper) is extended to a method for deriving an implementation of a
program transformation from a specification of the program transformation. We use program slicing as an example
transformation since this is of interest outside the program transformation community. We develop a formal specification
for program slicing in the form of a WSL specification statement which is refined into a simple slicing algorithm by applying
a sequence of general purpose program

07 Developing a Single Model and Test Prioritization Strategies for Event-Driven Software

5



Event-Driven Software (EDS) can change state based on incoming events; common examples are GUI and Web applications.
These EDSs pose a challenge to testing because there are a large number of possible event sequences that users can
invoke through a user interface. While valuable contributions have been made for testing these two subclasses of EDS, such
efforts have been disjoint. This work provides the first single model that is generic enough to study GUI and Web
applications together. In this paper, we use the model to define generic prioritization criteria that are applicable to both GUI
and Web applications. Our ultimate goal is to evolve the model and use it to develop a unified theory of how all EDS should
be tested. An empirical study reveals that the GUI and Web-based applications, when recast using the new model, show
similar behavior.

08 Dynamic Qos Management and Optimization in Service-Based Systems

Service-based systems that are dynamically composed at runtime to provide complex, adaptive functionality are currently
one of the main development paradigms in software engineering. However, the Quality of Service (QoS) delivered by these
systems remains an important concern, and needs to be managed in an equally adaptive and predictable way. To address
this need, we introduce a novel, tool-supported framework for the development of adaptive service-based systems called
QoSMOS (QoS Management and Optimization of Service-based systems). QoSMOS can be used to develop service-based

6


systems that achieve their QoS requirements through dynamically adapting to changes in the system state, environment,
and workload. QoSMOS service-based systems translate high-level QoS requirements specified by their administrators into
probabilistic temporal logic formulae, which are then formally and automatically analyzed to identify and enforce optimal
system configurations. The QoSMOS self-adaptation mechanism can handle reliability and performance-related QoS
requirements, and can be integrated into newly developed solutions or legacy systems. The effectiveness and scalability of
the approach are validated using simulations and a set of experiments based on an implementation of an adaptive service-
based system for remote medical assistance.

09 Efficient Consistency Measurement Based on Behavioral Profiles of process Model

Engineering of process-driven business applications can be supported by process modeling efforts in order to bridge the
gap between business requirements and system specifications. However, diverging purposes of business process modeling
initiatives have led to significant problems in aligning related models at different abstract levels and different perspectives.
Checking the consistency of such corresponding models is a major challenge for process modeling theory and practice. In
this paper, we take the inappropriateness of existing strict notions of behavioral equivalence as a starting point. Our
contribution is a concept called behavioral profile that captures the essential behavioral constraints of a process model. We
show that these profiles can be computed efficiently, i.e., in cubic time for sound free-choice Petri nets w.r.t. their number of

7


places and transitions.

10 Securing Cookies with a MAC Address Encrypted Key Ring

Most web services providers use cookies to personalize the customers’ access to the website. A cookie contains a user’s privacy
and important identification which can be used to identify the user. However, cookies are not as safe as we take it for granted. There
are still some potential safety hazards in cookies. For example, the contents in the cookies can be easily changed, thus it will result
in some safety threats to the user or the website. This paper proposes a new cookie security policy based on a MAC address
encrypted key ring. It can make the cookies have higher confidentiality and higher efficiency. It is also easy to deploy and meets the
user’s higher security requirements.

11 From UML to Petri Nets: The PCM-Based Methodology

8



In this paper, we present an evaluation methodology to validate the performance of a UML model, representing software
architecture. The proposed approach is based on open and well-known standards: UML for software modeling and the OMG
Profile for Schedulability, Performance, and Time Specification for the performance annotations into UML models. Such
specifications are collected in an intermediate model, called the Performance Context Model (PCM). The intermediate model
is translated into a performance model which is subsequently evaluated. The paper is focused on the mapping from the PCM
to the performance domain.

12 Genetic Algorithms for Randomized Unit Testing

Randomized testing is an effective method for testing software units. The thoroughness of randomized unit testing varies
widely according to the settings of certain parameters, such as the relative frequencies with which methods are called. In
this paper, we describe Nighthawk, a system which uses a genetic algorithm (GA) to find parameters for randomized unit
testing that optimize test coverage. Designing GAs is somewhat of a black art. We therefore use a feature subset selection
(FSS) tool to assess the size and content of the representations within the GA. Using that tool, we can reduce the size of the
representation substantially while still achieving most of the coverage found using the full representation. Our reduced GA
achieves almost the same results as the full system, but in only 10 percent of the time. These results suggest that FSS could

9


significantly optimize metaheuristic search-based software engineering tools.

13 Improving Source Code Lexicon via Traceability and Information Retrieval

The paper presents an approach helping developers to maintain source code identifiers and comments consistent with high-
level artifacts. Specifically, the approach computes and shows the textual similarity between source code and related high-
level artifacts. Our conjecture is that developers are induced to improve the source code lexicon, i.e., terms used in
identifiers or comments, if the software development environment provides information about the textual similarity between
the source code under development and the related high-level artifacts. The proposed approach also recommends candidate
identifiers built from high-level artifacts related to the source code under development and has been implemented as an
Eclipse plug-in, called COde Comprehension Nurturant Using Traceability (COCONUT). The paper also reports on two
controlled experiments performed with master’s and bachelor’s students. The goal of the experiments is to evaluate the
quality of identifiers and comments (in terms of their consistency with high-level artifacts) in the source code produced
when using or not using COCONUT.

10



14 Loupe: Verifying Publish-Subscribe Architectures with a Magnifying Lens

The Publish-Subscribe (P/S) communication paradigm fosters high decoupling among distributed components. This
facilitates the design of dynamic applications, but also impacts negatively on their verification, making it difficult to reason
on the overall federation of components. In addition, existing P/S infrastructures offer radically different features to the
applications, e.g., in terms of message reliability. This further complicates the verification as its outcome depends on the
specific guarantees provided by the underlying P/S system. Although model checking has been proposed as a tool for the
verification of P/S architectures, existing solutions overlook many characteristics of the underlying communication
infrastructure to avoid state explosion problems. To overcome these limitations, the Loupe domain-specific model checker
adopts a different approach.

11



15 A Web Development Platform Comparison by an Exploratory Experiment Searching for Emergent Platform Properties

Background: For developing Web-based applications, there exist several competing and widely used technological
platforms (consisting of a programming language, framework(s), components, and tools), each with an accompanying
development culture and style. Research question: Do Web development projects exhibit emergent process or product
properties that are characteristic and consistent within a platform, but show relevant substantial differences across
platforms or do team-to-team individual differences outweigh such differences, if any? Such a property could be positive
(i.e., a platform advantage), negative, or neutral, and it might be unobvious which is which. Method: In a nonrandomized,
controlled experiment, framed as a public contest called “Platforms,” top-class teams of three professional programmers
competed to implement the same requirements for a Web based application within 30 hours. Three different platforms (Java
EE, PHP, or Perl) were used by three teams each. We compare the resulting nine products and process records along many
dimensions, both external (usability, functionality, reliability, security, etc.) and internal (size, structure, modifiability, etc.)

12



16 Self-Supervising BPEL Processes

Service compositions suffer changes in their partner services. Even if the composition does not change, its behavior may
evolve over time and become incorrect. Such changes cannot be fully foreseen through prerelease validation, but impose a
shift in the quality assessment activities. Provided functionality and quality of service must be continuously probed while
the application executes, and the application itself must be able to take corrective actions to preserve its dependability and
robustness. We propose the idea of self-supervising BPEL processes, that is, special-purpose compositions that assess
their behavior and react through user-defined rules. Supervision consists of monitoring and recovery. The former checks the
system’s execution to see whether everything is proceeding as planned, while the latter attempts to fix any anomalies..

17 Semi-Proving: An Integrated Method for Program Proving, Testing, and Debugging

We present an integrated method for program proving, testing, and debugging. Using the concept of metamorphic relations,
we select necessary properties for target programs. For programs where global symbolic evaluation can be conducted and

13


the constraint expressions involved can be solved, we can either prove that these necessary conditions for program
correctness are satisfied or identify all inputs that violate the conditions. For other programs, our method can be converted
into a symbolic-testing approach.

.
18 Software Module Clustering as a Multi-Objective Search Problem

Software module clustering is the problem of automatically organizing software units into modules to improve program
structure. There has been a great deal of recent interest in search-based formulations of this problem in which module
boundaries are identified by automated search, guided by a fitness function that captures the twin objectives of high
cohesion and low coupling in a single-objective fitness function. This paper introduces two novel multi-objective
formulations of the software module clustering problem, in which several different objectives (including cohesion and
coupling) are represented separately. In order to evaluate the effectiveness of the multi-objective approach, a set of
experiments was performed on 17 real-world module clustering problems.

14



19 Systematic Review and Aggregation of Empirical Studies on Elicitation Techniques

We have located the results of empirical studies on elicitation techniques and aggregated these results to gather empirically
grounded evidence. Our chosen surveying methodology was systematic review, whereas we used an adaptation of
comparative analysis for aggregation because meta-analysis techniques could not be applied. The review identified 564
publications from the SCOPUS, IEEEXPLORE, and ACM DL databases, as well as Google. We selected and extracted data
from 26 of those publications. The selected publications contain 30 empirical studies. These studies were designed to test
43 elicitation techniques and 50 different response variables. We got 100 separate results from the experiments. The
aggregation generated 17 pieces of knowledge about the interviewing, laddering, sorting, and protocol analysis elicitation
techniques. We provide a set of guidelines based on the gathered pieces of knowledge.

15



20 Verifying the Evolution of Probability Distributions Governed by a DTMC

We propose a new probabilistic temporal logic, iLTL, which captures properties of systems whose state can be represented
by probability mass functions (pmfs). Using iLTL, we can specify reachability to a state (i.e., a pmf), as well as properties
representing the aggregate (expected) behavior of a system. We then consider a class of systems whose transitions are
governed by a Markov Chain—in this case, the set of states a system may be in is specified by the transitions of pmfs from
all potential initial states to the final state. We then provide a model checking algorithm to check iLTL properties of such
systems. Unlike existing model checking techniques, which either compute the portions of the computational paths that
satisfy a specification or evaluate properties along a single path of pmf transitions, our model checking technique enables
us to do a complete analysis on the expected behaviors of large-scale systems

16

Software eng

More Related Content

Similar to Software eng (20)

Recently uploaded (20)

Software eng