Software testing is presented as a so-called theme within which different
authors and groups have defined different subjects each of these subjects
having a different focus on testing. A uniform concept of software testing is
non-existent and the space of possible coherent perspectives on software
testing, each fitting within the theme, is viewed as being spanned by five
dimensions, each dimension representing two opposite views with a variety of
intermediate views in between.

The paper addresses aggregation issues for composite (modular) solutions. A
systemic view point is suggested for various aggregation problems. Several
solution structures are considered: sets, set morphologies, trees, etc. Mainly,
the aggregation approach is targeted to set morphologies. The aggregation
problems are based on basic structures as substructure, superstructure,
median/consensus, and extended median/consensus.

We derive an abstract computational model from a sequential computational
model that is generally used for function execution. This abstract
computational model allows for the concurrent execution of functions. We
discuss concurrent models for function execution as implementations from the
abstract computational model. We give an example of a particular concurrent
function construct that can be implemented on a concurrent machine model using
multi-threading.

Users wanting to monitor distributed or component-based systems often
perceive them as monolithic systems which, seen from the outside, exhibit a
uniform behaviour as opposed to many components displaying many local
behaviours that together constitute the system's global behaviour. This level
of abstraction is often reasonable, hiding implementation details from users
who may want to specify the system's global behaviour in terms of an LTL
formula.

This paper consider an MMLE (Modified Maximum Likelihood Estimation) based
scheme to estimate software reliability using exponential distribution. The
MMLE is one of the generalized frameworks of software reliability models of Non
Homogeneous Poisson Processes (NHPPs). The MMLE gives analytical estimators
rather than an iterative approximation to estimate the parameters. In this
paper we proposed SPC (Statistical Process Control) Charts mechanism to
determine the software quality using inter failure times data.

Large Intelligent Systems are so complex these days that an urgent need for
designing such systems in best available way is evolving. Modeling is the
useful technique to show a complex real world system into the form of
abstraction, so that analysis and implementation of the intelligent system
become easy and is useful in gathering the prior knowledge of system that is
not possible to experiment with the real world complex systems.

Accurate software cost and schedule estimation are essential for software
project success. Often it referred to as the "black art" because of its
complexity and uncertainty, software estimation is not as difficult or puzzling
as people think. In fact, generating accurate estimates is straightforward-once
you understand the intensity of uncertainty and framework for the modeling
process. The mystery to successful software estimation-distilling academic
information and real-world experience into a practical guide for working
software professionals.

In the component-based software development, the selection step is very
important. It consists of searching and selecting appropriate software
components from a set of candidate components in order to satisfy the
developer-specific requirements. In the selection process, both functional and
non-functional requirements are generally considered. In this paper, we focus
only on the QoS, a subset of non-functional characteristics, in order to
determine the best components for selection. The component selection based on
the QoS is a hard task due to the QoS descriptions heterogeneity.

This volume contains the final and revised versions of the papers presented
at the 7th International Workshop on Automated Specification and Verification
of Web Systems (WWV 2011). The workshop was held in Reykjavik, Iceland, on June
9, 2011, as part of DisCoTec 2011. The aim of the WWV workshop series is to
provide an interdisciplinary forum to facilitate the cross-fertilization and
the advancement of hybrid methods that exploit concepts and tools drawn from
Rule-based programming, Software engineering, Formal methods and Web-oriented
research.

Computation nowadays is becoming inherently concurrent, either because of
characteristics of the hardware (with multicore processors becoming
omnipresent) or due to the ubiquitous presence of distributed systems
(incarnated in the Internet). Computational systems are therefore typically
distributed, concurrent, mobile, and often involve composition of heterogeneous
components.

This paper presents the Eclipse plug-ins for the Task Flow model in the
Discovery Method. These plug-ins provide an IDE for the Task Algebra compiler
and the model-checking tools. The Task Algebra is the formal representation for
the Task Model and it is based on simple and compound tasks. The model-checking
techniques were developed to validate Task Models represented in the algebra.

A formal definition of the semantics of a domain-specific language (DSL) is a
key prerequisite for the verification of the correctness of models specified
using such a DSL and of transformations applied to these models. For this
reason, we implemented a prototype of the semantics of a DSL for the
specification of systems consisting of concurrent, communicating objects. Using
this prototype, models specified in the DSL can be transformed to labeled
transition systems (LTS).

The starting point of this paper is a system described in form of a UML class
diagram where system states are characterized by OCL invariants and system
transitions are defined by OCL pre- and postconditions. The aim of our approach
is to assist the developer in learning about the consequences of the described
system states and transitions and about the formal implications of the
properties that are explicitly given.

This paper reconsiders refinements which introduce actions on the concrete
level which were not present at the abstract level. It draws a distinction
between concrete actions which are "perspicuous" at the abstract level, and
changes of granularity of actions between different levels of abstraction.

In previous work we have described how refinements can be checked using a
temporal logic based model-checker, and how we have built a model-checker for Z
by providing a translation of Z into the SAL input language. In this paper we
draw these two strands of work together and discuss how we have implemented
refinement checking in our Z2SAL toolset.

Refinement is one of the cornerstones of a formal approach to software
engineering: the process of developing a more detailed design or implementation
from an abstract specification through a sequence of mathematically-based steps
that maintain correctness with respect to the original specification.

Software is among the most complex endeavors of the human mind; large scale
systems can have tens of millions of lines of source code. However, seldom is
complexity measured above the lowest level of code, and sometimes source code
files or low level modules. In this paper a hierarchical approach is explored
in order to find a set of metrics that can measure higher levels of
organization. These metrics are then used on a few popular free software
packages (totaling more than 25 million lines of code) to check their
efficiency and coherency.

There is a gap between our ability to reuse high-level concepts in software
design and our ability to reuse the code implementing them. Language Oriented
Programming (LOP) is a software development paradigm that aims to close this
gap, through extensive use of Domain Specific Languages (DSLs). With LOP, the
high-level reusable concepts become reusable DSL constructs, and their
translation into code level concepts is done in the DSL implementation.
Particular products are implemented using DSL code, thus reusing only
high-level concepts.

Fiji National University is encountering many difficulties with its current
administrative systems. These difficulties include accessibility, scalability,
performance, flexibility and integration. We propose a new campus information
system, FNU-CIS to addresses these difficulties. FNU-CIS has the potential to
provide wide range of the services for students and staffs at the university.
In order to assist in the design and implementation of proposed FNU-CIS, we
present an overview, software architecture and prototype implementation of our
proposed system.

The context of a software developer is something hard to define and capture,
as it represents a complex network of elements across different dimensions that
are not limited to the work developed on an IDE. We propose the definition of a
software developer context model that takes into account all the dimensions
that characterize the work environment of the developer. We are especially
focused on what the software developer context encompasses at the project level
and how it can be captured.

Interface adaptation allows code written for one interface to be used with a
software component with another interface. When multiple adapters are chained
together to make certain adaptations possible, we need a way to analyze how
well the adaptation is done in case there are more than one chains that can be
used. We introduce an approach to precisely analyzing the loss in an interface
adapter chain using a simple form of abstract interpretation.

We give a brief characterisation of the purposes and forms of documentation
in and of spreadsheets.

Normally, program execution spends most of the time on loops. Automated test
data generation devotes special attention to loops for better coverage.
Automated test data generation for programs having loops with variable number
of iteration and variable length array is a challenging problem. It is so
because the number of paths may increase exponentially with the increase of
array size for some programming constructs, like merge sort. We propose a
method that finds heuristic for different types of programming constructs with
loops and arrays.

This article contributes to the design and the verification of trusted
components and services. The contracts are declined at several levels to cover
then different facets, such as component consistency, compatibility or
correctness. The article introduces multilevel contracts and a
design+verification process for handling and analysing these contracts in
component models. The approach is implemented with the COSTO platform that
supports the Kmelia component model. A case study illustrates the overall
approach.

A key objective for ubiquitous environments is to enable system
interoperability between system's components that are highly heterogeneous. In
particular, the challenge is to embed in the system architecture the necessary
support to cope with behavioral diversity in order to allow components to
coordinate and communicate. The continuously evolving environment further asks
for an automated and on-the-fly approach. In this paper we present the design
building blocks for the dynamic and on-the-fly interoperability between
heterogeneous components.

The notion of contract aware components has been published roughly ten years
ago and is now becoming mainstream in several fields where the usage of
software components is seen as critical. The goal of this paper is to survey
domains such as Embedded Systems or Service Oriented Architecture where the
notion of contract aware components has been influential. For each of these
domains we briefly describe what has been done with this idea and we discuss
the remaining challenges.

This volume contains the proceedings of WCSI 2010, the International Workshop
on Component and Service Interoperability. WCSI 2010 was held in Malaga (Spain)
on June 29th, 2010 as a satellite event of the TOOLS 2010 Federated
Conferences. The papers published in this volume tackle different issues that
are currently central to our community, namely definition of expressive
interface languages, formal models and approaches to software composition and
adaptation, interface-based compatibility and substitutability, and
verification techniques for distributed software.

This paper describes the rationale, curriculum and subject matter of a new
MSc module being taught on an MSc Finance and Information Management course at
the University of Wales Institute in Cardiff. Academic research on spreadsheet
risks now has some penetration in academic literature and there is a growing
body of knowledge on the subjects of spreadsheet error, human factors,
spreadsheet engineering, "best practice", spreadsheet risk management and
various techniques used to mitigate spreadsheet errors.

Message Sequence Charts (MSCs) are an appealing visual formalism mainly used
in the early stages of system design to capture the system requirements.
However, if we move towards an implementation, an executable specifications
related in some fashion to the MSC-based requirements must be obtained. The
MSCs can be used effectively to specify the bus protocol in the way where
high-level transition systems is used to capture the control flow of the system
components of the protocol and MSCs to describe the non-atomic component
interactions.

This volume contains the papers presented at the fourth international
workshop on Testing, Analysis and Verification of Software, which was
associated with the 25th IEEE/ACM International Conference on Automated
Software Engineering (ASE 2010). The collection of papers includes research on
formal specification, model-checking, testing, and debugging of Web software.

In previous work we have studied how an explicit representation of background
knowledge associated with a specific spreadsheet can be exploited to alleviate
usability problems with spreadsheet-based applications. We have implemented
this approach in the SACHS system to provide a semantic help system for
spreadsheets applications. In this paper, we evaluate the (comprehension)
coverage of SACHS on an Excel-based financial controlling system via a
"Wizard-of-Oz" experiment. This shows that SACHS adds significant value, but
systematically misses important classes of explanations.

Previous spreadsheet inspection experiments have had human subjects look for
seeded errors in spreadsheets. In this study, subjects attempted to find errors
in human-developed spreadsheets to avoid the potential artifacts created by
error seeding. Human subject success rates were compared to the successful
rates for error-flagging by spreadsheet static analysis tools (SSATs) applied
to the same spreadsheets. The human error detection results were comparable to
those of studies using error seeding.

Although experts diverge on how best to improve spreadsheet quality, it is
generally agreed that more time needs to be spent testing spreadsheets.
Ideally, experienced and trained spreadsheet engineers would carry this out,
but quite often this is neither practical nor possible. Many spreadsheets are a
legacy, developed by staff that have since moved on, or indeed modified by many
staff no longer employed by the organisation. When such spreadsheets fall into
the hands of inexperienced, non-experts, any features that reduce error
visibility may become a risk.

In the insurance industry, spreadsheets have emerged as an invaluable tool to
for product pricing, because it is relatively straightforward to create and
maintain complex pricing models using Excel. In fact, Excel is often preferred
to "hard-code" whenever there are frequent changes to the calculations and
business logic which under-pin the pricing of an insurance product.

To maximize efficiency in time and space, allocations and deallocations, in
the exact linear algebra library \linbox, must always occur in the founding
scope. This provides a simple lightweight allocation model. We present this
model and its usage for the rebinding of matrices between different coefficient
domains. We also present automatic tools to speed-up the compilation of
template libraries and a software abstraction layer for the introduction of
transparent parallelism at the algorithmic level.

Because of the importance of object oriented methodologies, the research in
developing new measure for object oriented system development is getting
increased focus. The most of the metrics need to find the interactions between
the objects and modules for developing necessary metric and an influential
software measure that is attracting the software developers, designers and
researchers. In this paper a new interactions are defined for object oriented
system. Using these interactions, a parser is developed to analyze the existing
architecture of the software.

Although software managers are generally good at new project estimation,
their experience of scheduling rework tends to be poor. Inconsistent or
incorrect effort estimation can increase the risk that the completion time for
a project will be problematic. To continually alter software maintenance
schedules during software maintenance is a daunting task. Our proposed
framework, validated in a case study confirms that the variables resulting from
requirements changes suffer from a number of problems, e.g., the coding used,
end user involvement and user documentation.

This work proposes a methodology for source code quality and static behaviour
evaluation of a software system, based on the standard ISO/IEC-9126. It uses
elements automatically derived from source code enhanced with expert knowledge
in the form of quality characteristic rankings, allowing software engineers to
assign weights to source code attributes. It is flexible in terms of the set of
metrics and source code attributes employed, even in terms of the ISO/IEC-9126
characteristics to be assessed.

In this paper we present a compositional semantics for the channel-based
coordination language Reo which enables the analysis of quality of service
(QoS) properties of service compositions. For this purpose, we annotate Reo
channels with stochastic delay rates and explicitly model data-arrival rates at
the boundary of a connector, to capture its interaction with the services that
comprise its environment.

Dependency analysis is a technique to identify and determine data
dependencies between service protocols. Protocols evolving concurrently in the
service composition need to impose an order in their execution if there exist
data dependencies. In this work, we describe a model to formalise context-aware
service protocols. We also present a composition language to handle dynamically
the concurrent execution of protocols. This language addresses data dependency
issues among several protocols concurrently executed on the same user device,
using mechanisms based on data semantic matching.

Software visualization can be of great use for understanding and exploring a
software system in an intuitive manner. Spatial representation of software is a
promising approach of increasing interest. However, little is known about how
developers interact with spatial visualizations that are embedded in the IDE.
In this paper, we present a pilot study that explores the use of Software
Cartography for program comprehension of an unknown system.

This paper introduces CONFIGEN, a tool that helps modularizing software.
CONFIGEN allows the developer to select a set of elementary components for his
software through an interactive interface. Configuration files for use by
C/assembly code and Makefiles are then automatically generated, and we
successfully used it as a helper tool for complex system software refactoring.
CONFIGEN is based on propositional logic, and its implementation faces hard
theoretical problems.

The overall goal of the described research project was to create applicable
quality assurance patterns for Java software systems using the aspect-oriented
programming language extension AspectJ 5. We tried to develop aspects to check
static quality criteria as a variable mutator convention and architectural
layering rules. We successfully developed aspects for automating the following
dynamic quality criteria: Parameterized Exception Chaining, Comfortable
Declaration of Parameterized Exceptions, Not-Null Checking of Reference
Variables.

The Eclipse Graphical Modeling (GMF) Framework provides the major approach
for implementing visual languages on top of the Eclipse platform. GMF relies on
a family of modeling languages to describe different aspects of the visual
language and its implementation in an editor. GMF uses a model-driven approach
to map the different GMF models to Java code. The framework, as it stands,
provides very little support for evolution. In particular, there is no support
for propagating changes from say the domain model (i.e., the abstract syntax of
the visual language) to other models.

Software that cannot change is condemned to atrophy: it cannot accommodate
the constant revision and re-negotiation of its business goals nor intercept
the potential of new technology. To accommodate change in such systems we have
defined an active software architecture to be: dynamic in that the structure
and cardinality of the components and interactions are not statically known;
updatable in that components can be replaced dynamically; and evolvable in that
it permits its executing specification to be changed.

This index covers the final course project reports for COMP5541 Winter 2010
at Concordia University, Montreal, Canada, Tools and Techniques for Software
Engineering by 4 teams trying to capture the requirements, provide the design
specification, configuration management, testing and quality assurance of their
partial implementation of the Unified University Inventory System (UUIS) of an
Imaginary University of Arctica (IUfA). Their results are posted here for
comparative studies and analysis.

Behavior Driven Development (NORTH, 2006) is a specification technique that
is growing in acceptance in the Agile methods communities. BDD allows to
securely verify that all functional requirements were treated properly by
source code, by connecting the textual description of these requirements to
tests.

Today, reusable components are available in several repositorys. These are
certainly conceived for re-use. However, this re-use is not immediate, it
requires, in effect, to pass by some essential conceptual operations, among
which in particular, research, integration, adaptation, and composition. We are
interested in the present work to the problem of semantic integration of
heterogeneous Business Components. This problem is often put in syntactical
terms, while the real stake is of semantic order.

A complex pervasive system is typically composed of many cooperating
\emph{nodes}, running on machines with different capabilities, and pervasively
distributed across the environment. These systems pose several new challenges
such as the need for the nodes to manage autonomously and dynamically in order
to adapt to changes detected in the environment. To address the above issue, a
number of autonomic frameworks has been proposed. These usually offer either
predefined self-management policies or programmatic mechanisms for creating new
policies at design time.

In this paper, we build an interpreter by reusing host language functions
instead of recoding mechanisms of function application that are already
available in the host language (the language which is used to build the
interpreter). In order to transform user-defined functions into host language
functions we use combinatory logic : lambda-abstractions are transformed into a
composition of combinators. We provide a mechanically checked proof that this
step is correct for the call-by-value strategy with imperative features.

In the 52-page document, we describe our approach to the Software
Requirements Specification of the IUfA's UUIS prototype. This includes the
overall system description, functional requirements, non-functional
requirements, use cases, the corresponding data dictionary for all entities
involved, mock user interface (UI) design, and the overall projected cost
estimate. The design specification of UUIS can be found in arXiv:1005.0665.

The purpose of this document is to provide technical specifications concerned
to the Design of the University Unified Inventory System - Web Portal, of the
UIfA. The Team of Developers used a Feedback Waterfall approach to build up the
system, under an Object Oriented paradigm. The architectural model followed was
the Model-View-Controller, mixed with a Mapper layer between the database and
the Model. Some of the patterns utilized in the developing of the System were
the Observer Pattern, the Command Pattern, and the Mapper Pattern.

This document provides a description of the technical design for Unified
University Inventory System - Web Portal. This document's primary purpose is to
describe the technical vision for how business requirements will be realized.
This document provides an architectural overview of the system to depict
different aspects of the system. This document also functions as a foundational
reference point for developers.

Measuring software maintainability early in the development life cycle,
especially at the design phase, may help designers to incorporate required
enhancement and corrections for improving maintainability of the final
software. This paper developed a multivariate linear model 'Maintainability
Estimation Model for Object-Oriented software in Design phase' (MEMOOD), which
estimates the maintainability of class diagrams in terms of their
understandability and modifiability.

A UML based metamodel for Bunge-Wand-Weber (BWW) ontology is presented. BWW
ontology is a generic framework for analysis and conceptualization of real
world objects. It includes categories that can be applied to analyze and
classify objects found in an information system. In the context of BWW
ontology, the metamodel is a representation of the ontological categories and
relationships among them. An objective behind developing an object-oriented
metamodel has been to model BWW ontology in terms of widely used notions in
software development.

Cloud computing is an emerging platform of service computing designed for
swift and dynamic delivery of assured computing resources. Cloud computing
provide Service-Level Agreements (SLAs) for guaranteed uptime availability for
enabling convenient and on-demand network access to the distributed and shared
computing resources. Though the cloud computing paradigm holds its potential
status in the field of distributed computing, cloud platforms are not yet to
the attention of majority of the researchers and practitioners.

Reliable effort estimation remains an ongoing challenge to software
engineers. Accurate effort estimation is the state of art of software
engineering, effort estimation of software is the preliminary phase between the
client and the business enterprise. The relationship between the client and the
business enterprise begins with the estimation of the software. The credibility
of the client to the business enterprise increases with the accurate
estimation. Effort estimation often requires generalizing from a small number
of historical projects.

Computer System Administration and Network Administration are few such areas
where Practical Extraction Reporting Language (Perl) has robust utilization
these days apart from Bioinformatics. The key role of a System/Network
Administrator is to monitor log files. Log file are updated every day. To scan
the summary of large log files and to quickly determine if there is anything
wrong with the server or network we develop a Firewall Log Status Reporter
(SRr).

The use of World Web Wide for distance education has received increasing
attention over the past decades. The real challenge of adapting this technology
for engineering education and training is to facilitate the laboratory
experiments via Internet. In the sciences, measurement plays an important role.
The accuracy of the measurement, as well as the units, help scientists to
better understand phenomena occurring in nature. This paper introduces
Metrology educators to the use and adoption of Java-applets in order to create
virtual, online Metrology laboratories for students.

Software engineering is one of the most recent additions in various
disciplines of system engineering. It has emerged as a key obedience of system
engineering in a quick succession of time. Various Software Engineering
approaches are followed in order to produce comprehensive software solutions of
affordable cost with reasonable delivery timeframe with less uncertainty.

This document reports on the use of an algebraic, visual, formal approach to
the specification of patterns for the formalization of the GoF design patterns.
The approach is based on graphs, morphisms and operations from category theory
and exploits triple graphs to annotate model elements with pattern roles. Being
based on category theory, the approach can be applied to formalize patterns in
different domains. Novel in our proposal is the possibility of describing
(nested) variable submodels, inter-pattern synchronization across several
diagrams (e.g.

There is a growing interest in techniques for detecting whether a logic
specification is satisfied too easily, or vacuously. For example, the
specification "every request is eventually followed by an acknowledgment" is
satisfied vacuously by a system that never generates any requests. Vacuous
satisfaction misleads users of model-checking into thinking that a system is
correct.

Requirement Analysis is an important phase in software development which
deals with understanding the customers requirements. It includes the collection
of information from the customer, which is regarding the customers requirements
and what he expects from the software which is to be developed. By doing so,
you can have a better understanding of what the customer actually needs and
hence can deliver the output as per the customers requirements.

The design structure of OO software has decisive impact on its quality. The
design must be strongly correlated with quality characteristics like
analyzability, changeability, stability and testability, which are important
for maintaining the system. But due to the diversity and complexity of the
design properties of OO system e.g. Polymorphism, encapsulation, coupling it
becomes cumbersome.

Software testing is the important phase of software development process. But,
this phase can be easily missed by software developers because of their limited
time to complete the project. Since, software developers finish their software
nearer to the delivery time; they dont get enough time to test their program by
creating effective test cases. . One of the major difficulties in software
testing is the generation of test cases that satisfy the given adequacy
criterion Moreover, creating manual test cases is a tedious work for software
developers in the final rush hours.

Software Visualization encompasses the development and evaluation of methods
for graphically representing different aspects of methods of software,
including its structure, execution and evolution. Creating visualizations helps
the user to better understand complex phenomena.

Agile development processes and component-based software architectures are
two software engineering approaches that contribute to enable the rapid
building and evolution of applications. Nevertheless, few approaches have
proposed a framework to combine agile and component-based development, allowing
an application to be tested throughout the entire development cycle. To address
this problematic, we have built CALICO, a model-based framework that allows
applications to be safely developed in an iterative and incremental manner.

This paper considers economic intelligence contribution to exploit individual
and collective images of change, in ICT design decision-making. Technical
devices meeting with real use situations often gives the opportunity to emerge
mental images, that a innovation process, through its unprecedented nature, can
not anticipate. Although methodologies exists for quality and design project
management, the survey we conduct among small ICT publishers, show how they are
not very suitable for small firms. This elements taken into account, we try to
build a proposition of exploration ? analyze ?

Although a lot of research has taken place in Object Oriented Design of
software for Real Time systems and mapping of design models to implementation
models, these methodologies are applicable to systems which are less complex
and small in source code size. However, in practice, the size of the software
for real time applications is growing. The run time architecture of real time
applications is becoming increasingly complex. In this paper, we present a
generic approach for mapping the design models to run time architectures
resulting in combination of processes and threads.

A common application of spreadsheets is the development of models that
deliver projections of the future financial statements of companies established
to pursue ventures that are subject to project financing. A survey of 11 such
spreadsheets prepared by a range of organisations shows that the amount of
self-testing included in such models ranges between one formula of testing for
each three formulae of calculation, down to essentially no self-testing at all.

The software industry is successful, if it can draw the complete attention of
the customers towards it. This is achievable if the organization can produce a
high quality product. To identify a product to be of high quality, it should be
free of defects, should be capable of producing expected results. It should be
delivered in an estimated cost, time and be maintainable with minimum effort.

This paper provides an outline of a formal approach that we are developing
for modelling Virtual Organisations (VOs) and their Breeding Environments
(VBEs). We propose different levels of representation for the functional
structures and processes that VBEs and VOs involve, which are independent of
the specificities of the infrastructures (organisational and technical) that
support the functioning of VBEs. This allows us to reason about properties of
tasks performed within VBEs and services provided through VOs without
committing to the way in which they are implemented.

In this paper, an approach to facilitate the treatment with variabilities in
system families is presented by explicitly modelling variants. The proposed
method of managing variability consists of a variant part, which models
variants and a decision table to depict the customisation decision regarding
each variant. We have found that it is easy to implement and has advantage over
other methods. We present this model as an integral part of modelling system
families.

The primary focus of Monte Carlo simulation is to identify and quantify risk
related to uncertainty and variability in spreadsheet model inputs. The stress
of Monte Carlo simulation often reveals logical errors in the underlying
spreadsheet model that might be overlooked during day-to-day use or traditional
"what-if" testing. This secondary benefit of simulation requires a trained eye
to recognize warning signs of poor model construction.

The Function point analysis (FPA) method is the preferred scheme of
estimation for project managers to determine the size, effort, schedule,
resource loading and other such parameters. The FPA method by International
Function Point Users Group (IFPUG) has captured the critical implementation
features of an application through fourteen general system characteristics.
However, Non- functional requirements (NFRs) such as functionality,
reliability, efficiency, usability, maintainability, portability, etc. have not
been included in the FPA estimation method.

Service-oriented computing has emerged as the new area to address software as
a service. This paper proposes a model for component based development for
service-oriented systems and have created best practice guidelines on software
component design.

The growth in data traffic and the increased demand for quality of service
has meant current network systems need to be more efficient. The introduction
of improved routing systems to meet the increasing demand and varied protocols
to accommodate various scales of challenges in network efficiency has further
complicated the operations. This means a better mode of intelligence had to be
infused into networking for smoother operations and better autonomic features.
Cognitive networks are defined and analyzed in this angle.

Defect prevention is the most vital but habitually neglected facet of
software quality assurance in any project. If functional at all stages of
software development, it can condense the time, overheads and wherewithal
entailed to engineer a high quality product. The key challenge of an IT
industry is to engineer a software product with minimum post deployment
defects. This effort is an analysis based on data obtained for five selected
projects from leading software companies of varying software production
competence.

A feature-oriented product line is a family of programs that share a common
set of features. A feature implements a stakeholder's requirement, represents a
design decision and configuration option and, when added to a program, involves
the introduction of new structures, such as classes and methods, and the
refinement of existing ones, such as extending methods. With feature-oriented
decomposition, programs can be generated, solely on the basis of a user's
selection of features, by the composition of the corresponding feature code.

Additional requirements are set for mobile applications in relation to
applications for desktop computers. These requirements primarily concern the
support to different platforms on which such applications are performed, as
well as the requirement for providing more modalities of input/output
interaction.

A theory, graphical notation, mathematical calculus and implementation for
finding whether two given expressions can, at execution time, denote references
attached to the same object. Intended as the basis for a comprehensive solution
to the "frame problem" and as a complement to, or even a replacement for,
separation logic, shape analysis, ownership types and dynamic frames.

Software project management is an interpolation of project planning, project
monitoring and project termination. The substratal goals of planning are to
scout for the future, to diagnose the attributes that are essentially done for
the consummation of the project successfully, animate the scheduling and
allocate resources for the attributes. Software cost estimation is a vital role
in preeminent software project decisions such as resource allocation and
bidding. This paper articulates the conventional overview of software cost
estimation modus operandi available.

The complexity of software in embedded systems has increased significantly
over the last years so that software verification now plays an important role
in ensuring the overall product quality.

The task of simulation is often complicated for which many naive users often
seek for relatively easier solutions. In many cases, simulations are done
without any visual output which makes them non-attractive. In this paper, we
present ViSim; a new simulation tool that has a user-friendly graphical
interface. ViSim could be useful for researchers, students, teachers in their
works, and for the demonstration of various wireless network scenarios on
computer screen.

Software has become an integral part of everyday life. Everyday, millions of
people perform transaction through internet, ATM, mobile phone, they send email
and Egreetings, and use word processing and spreadsheet for various purpose.
People use software bearing in mind that it is reliable and can be trust upon
and the operation they perform is secured. Now, if these software have
exploitable security hole then how can they be safe for use. Security brings
value to software in terms of peoples trust.

Context consistency checking, the checking of specified constraint on
properties of contexts, is essential to context-aware applications. In order to
delineate and adapt to dynamic changes in the pervasive computing environment,
context-aware applications often need to specify and check behavioral
consistency constraints over the contexts. This problem is challenging mainly
due to the distributed and asynchronous nature of pervasive computing
environments. Specifically, the critical issue in checking behavioral
constraints is the temporal ordering of contextual activities.

We propose a new approach to testing conformance to a nondeterministic
specification, in which testing proceeds only as long as increased test
coverage is guaranteed.

We introduce a method to specify and analyse decentralised dynamic systems;
the method is based on the combination of an event-based multi-process system
specification approach with a multi-facet analysis approach that considers a
reference abstract model and several specific ones derived from the abstract
model in order to support facet-wise analysis. The method is illustrated with
the modelling and the analysis of a mobile ad-hoc network. The Event-B
framework and its related tools B4free and ProB are used to conduct the
experiments.

Free and Open Source Software (FOSS) distributions are complex software
systems, made of thousands packages that evolve rapidly, independently, and
without centralized coordination. During packages upgrades, corner case
failures can be encountered and are hard to deal with, especially when they are
due to misbehaving maintainer scripts: executable code snippets used to
finalize package configuration. In this paper we report a software
modernization experience, the process of representing existing legacy systems
in terms of models, applied to FOSS distributions.

In this letter, we propose a novel three-dimensional conceptual model for an
emerging service-oriented simulation paradigm. The model can be used as a
guideline or an analytic means to find the potential and possible future
directions of the current simulation frameworks. In particular, the model
inspects the crossover between the disciplines of modeling and simulation,
service-orientation, and software/systems engineering. Finally, two specific
simulation frameworks are studied as examples.

The development of pervasive computing has put the light on a challenging
problem: how to dynamically compose services in heterogeneous and highly
changing environments? We propose a survey that defines the service composition
as a sequence of four steps: the translation, the generation, the evaluation,
and finally the execution. With this powerful and simple model we describe the
major service composition middleware.

The advent of the Java Card standard has been a major turning point in smart
card technology. With the growing acceptance of this standard, understanding
the performance behavior of these platforms is becoming crucial. To meet this
need, we present in this paper a novel benchmarking framework to test and
evaluate the performance of Java Card platforms. MESURE tool is the first
framework which accuracy and effectiveness are independent from the particular
Java Card platform tested and CAD used.

One of the obstacles in automatic program proving is to obtain suitable loop
invariants.

The invariant of a loop is a weakened form of its postcondition (the loop's
goal, also known as its contract); the present work takes advantage of this
observation by using the postcondition as the basis for invariant inference,
using various heuristics such as "uncoupling" which prove useful in many
important algorithms.

Thanks to these heuristics, the technique is able to infer invariants for a
large variety of loop examples.