Abstract: The overriding goal of software engineering is to
provide a high quality system, application or a product. To achieve
this goal, software engineers must apply effective methods coupled
with modern tools within the context of a mature software process
[2]. In addition, it is also must to assure that high quality is realized.
Although many quality measures can be collected at the project
levels, the important measures are errors and defects. Deriving a
quality measure for reusable components has proven to be
challenging task now a days. The results obtained from the study are
based on the empirical evidence of reuse practices, as emerged from
the analysis of industrial projects. Both large and small companies,
working in a variety of business domains, and using object-oriented
and procedural development approaches contributed towards this
study. This paper proposes a quality metric that provides benefit at
both project and process level, namely defect removal efficiency
(DRE).
Abstract: Today-s economy is in a permanent change, causing
merger and acquisitions and co operations between enterprises. As a
consequence, process adaptations and realignments result in systems
integration and software development projects. Processes and
procedures to execute such projects are still reliant on craftsman-ship
of highly skilled workers. A generally accepted, industrialized
production, characterized by high efficiency and quality, seems
inevitable.
In spite of this, current concepts of software industrialization are
aimed at traditional software engineering and do not consider the
characteristics of systems integration. The present work points out
these particularities and discusses the applicability of existing
industrial concepts in the systems integration domain. Consequently
it defines further areas of research necessary to bring the field of
systems integration closer to an industrialized production, allowing a
higher efficiency, quality and return on investment.
Abstract: Real-time embedded systems should benefit from
component-based software engineering to handle complexity and
deal with dependability. In these systems, applications should not
only be logically correct but also behave within time windows.
However, in the current component based software engineering
approaches, a few of component models handles time properties in
a manner that allows efficient analysis and checking at the
architectural level. In this paper, we present a meta-model for
component-based software description that integrates timing
issues. To achieve a complete functional model of software
components, our meta-model focuses on four functional aspects:
interface, static behavior, dynamic behavior, and interaction
protocol. With each aspect we have explicitly associated a time
model. Such a time model can be used to check a component-s
design against certain properties and to compute the timing
properties of component assemblies.
Abstract: This paper looks into areas not covered by prominent
Agent-Oriented Software Engineering (AOSE) methodologies.
Extensive paper review led to the identification of two issues, first
most of these methodologies almost neglect semantic web and
ontology. Second, as expected, each one has its strength and
weakness and may focus on some phases of the development
lifecycle but not all of the phases. The work presented here builds
extensions to a highly regarded AOSE methodology (MaSE) in order
to cover the areas that this methodology does not concentrate on. The
extensions include introducing an ontology stage for semantic
representation and integrating early requirement specification from a
methodology which mainly focuses on that. The integration involved
developing transformation rules (with the necessary handling of nonmatching
notions) between the two sets of representations and
building the software which automates the transformation. The
application of this integration on a case study is also presented in the
paper. The main flow of MaSE stages was changed to smoothly
accommodate the new additions.
Abstract: Majority of Business Software Systems (BSS)
Development and Enhancement Projects (D&EP) fail to meet criteria
of their effectiveness, what leads to the considerable financial losses.
One of the fundamental reasons for such projects- exceptionally low
success rate are improperly derived estimates for their costs and time.
In the case of BSS D&EP these attributes are determined by the work
effort, meanwhile reliable and objective effort estimation still appears
to be a great challenge to the software engineering. Thus this paper is
aimed at presenting the most important synthetic conclusions coming
from the author-s own studies concerning the main factors of
effective BSS D&EP work effort estimation. Thanks to the rational
investment decisions made on the basis of reliable and objective
criteria it is possible to reduce losses caused not only by abandoned
projects but also by large scale of overrunning the time and costs of
BSS D&EP execution.
Abstract: Although achieving zero-defect software release is
practically impossible, software industries should take maximum
care to detect defects/bugs well ahead in time allowing only bare
minimums to creep into released version. This is a clear indicator of
time playing an important role in the bug detection. In addition to
this, software quality is the major factor in software engineering
process. Moreover, early detection can be achieved only through
static code analysis as opposed to conventional testing.
BugCatcher.Net is a static analysis tool, which detects bugs in .NET®
languages through MSIL (Microsoft Intermediate Language)
inspection. The tool utilizes a Parser based on Finite State Automata
to carry out bug detection. After being detected, bugs need to be
corrected immediately. BugCatcher.Net facilitates correction, by
proposing a corrective solution for reported warnings/bugs to end
users with minimum side effects. Moreover, the tool is also capable
of analyzing the bug trend of a program under inspection.
Abstract: This paper is a survey of current component-based
software technologies and the description of promotion and
inhibition factors in CBSE. The features that software components
inherit are also discussed. Quality Assurance issues in componentbased
software are also catered to. The feat research on the quality
model of component based system starts with the study of what the
components are, CBSE, its development life cycle and the pro &
cons of CBSE. Various attributes are studied and compared keeping
in view the study of various existing models for general systems and
CBS. When illustrating the quality of a software component an apt
set of quality attributes for the description of the system (or
components) should be selected. Finally, the research issues that can
be extended are tabularized.
Abstract: The importance of low power consumption is widely
acknowledged due to the increasing use of portable devices, which
require minimizing the consumption of energy. Energy dissipation is
heavily dependent on the software used in the system. Applying
design patterns in object-oriented designs is a common practice
nowadays. In this paper we analyze six design patterns and explore
the effect of them on energy consumption and performance.
Abstract: Global Software Development (GSD) projects are
passing through different boundaries of a company, country and even
in other continents where time zone differs between both sites.
Beside many benefits of such development, research declared plenty
of negative impacts on these GSD projects. It is important to
understand problems which may lie during the execution of GSD
project with different time zones. This research project discussed and
provided different issues related to time delays in GSD projects. In
this paper, authors investigated some of the time delay factors which
usually lie in GSD projects with different time zones. This
investigation is done through systematic review of literature.
Furthermore, the practices to overcome these delay factors which
have already been reported in literature and GSD organizations are
also explored through literature survey and case studies.
Abstract: Component-Based software engineering provides an
opportunity for better quality and increased productivity in software
development by using reusable software components [10]. One of the
most critical aspects of the quality of a software system is its
performance. The systematic application of software performance
engineering techniques throughout the development process can help
to identify design alternatives that preserve desirable qualities such
as extensibility and reusability while meeting performance objectives
[1]. In the present scenario, software engineering methodologies
strongly focus on the functionality of the system, while applying a
“fix- it-later" approach to software performance aspects [3]. As a
result, lengthy fine-tunings, expensive extra hard ware, or even
redesigns are necessary for the system to meet the performance
requirements. In this paper, we propose design based,
implementation independent, performance prediction approach to
reduce the overhead associated in the later phases while developing a
performance guaranteed software product with the help of Unified
Modeling Language (UML).
Abstract: This paper examines and compares several of the most common real time methods. These methods are CORE, YSM, MASCOT, JSD, DARTS, RTSAD, ADARTS, CODARTS, HOOD, HRT-HOOD, ROOM, UML, UML-RT. The methods are compared using attributes like i) usability, ii) compositionality and iii) proper RT notations available. Finally some comparison results are given and discussed.
Abstract: Software crisis refers to the situation in which the developers are not able to complete the projects within time and budget constraints and moreover these overscheduled and over budget projects are of low quality as well. Several methodologies have been adopted form time to time to overcome this situation and now in the focus is component based software engineering. In this approach, emphasis is on reuse of already existing software artifacts. But the results can not be achieved just by preaching the principles; they need to be practiced as well. This paper highlights some of the very basic elements of this approach, which has to be in place to get the desired goals of high quality, low cost with shorter time-to-market software products.
Abstract: The ever-growing usage of aspect-oriented
development methodology in the field of software engineering
requires tool support for both research environments and industry. So
far, tool support for many activities in aspect-oriented software
development has been proposed, to automate and facilitate their
development. For instance, the AJaTS provides a transformation
system to support aspect-oriented development and refactoring. In
particular, it is well established that the abstract interpretation of
programs, in any paradigm, pursued in static analysis is best served
by a high-level programs representation, such as Control Flow Graph
(CFG). This is why such analysis can more easily locate common
programmatic idioms for which helpful transformation are already
known as well as, association between the input program and
intermediate representation can be more closely maintained.
However, although the current researches define the good concepts
and foundations, to some extent, for control flow analysis of aspectoriented
programs but they do not provide a concrete tool that can
solely construct the CFG of these programs. Furthermore, most of
these works focus on addressing the other issues regarding Aspect-
Oriented Software Development (AOSD) such as testing or data flow
analysis rather than CFG itself. Therefore, this study is dedicated to
build an aspect-oriented control flow graph construction tool called
AJcFgraph Builder. The given tool can be applied in many software
engineering tasks in the context of AOSD such as, software testing,
software metrics, and so forth.
Abstract: Unified Modeling Language (UML) is a standard
language for modeling of a system. UML is used to visually specify
the structure and behavior of a system. The system requirements are
captured and then converted into UML specification. UML
specification uses a set of rules and notations, and diagrams to
specify the system requirements. In this paper, we present a tool for
developing the UML specification. The tool will ease the use of the
notations and diagrams for UML specification as well as increase the
understanding and familiarity of the UML specification. The tool will
also be able to check the conformance of the diagrams against each
other for basic compliance of UML specification.
Abstract: E-Appointment Scheduling (EAS) has been developed
to handle appointment for UMP students, lecturers in Faculty of
Computer Systems & Software Engineering (FCSSE) and Student
Medical Center. The schedules are based on the timetable and
university activities. Constraints Logic Programming (CLP) has been
implemented to solve the scheduling problems by giving
recommendation to the users in part of determining any available
slots from the lecturers and doctors- timetable. By using this system,
we can avoid wasting time and cost because this application will set
an appointment by auto-generated. In addition, this system can be an
alternative to the lecturers and doctors to make decisions whether to
approve or reject the appointments.
Abstract: Many agent-oriented software engineering
methodologies have been proposed for software developing; however
their application is still limited due to their lack of maturity.
Evaluating the strengths and weaknesses of these methodologies
plays an important role in improving them and in developing new
stronger methodologies. This paper presents an evaluation framework
for agent-oriented methodologies, which addresses six major areas:
concepts, notation, process, pragmatics, support for software
engineering and marketability. The framework is then used to
evaluate the Gaia methodology to identify its strengths and
weaknesses, and to prove the ability of the framework for promoting
the agent-oriented methodologies by detecting their weaknesses in
detail.