Technical Sessions
Refereed Papers
Session 1.1: Modeling
and Testing
AMDA: Matching the
Model-Driven-Architecture's goals using Extended Automata as a common
model for design and execution
David. Dayan (Israel), Rivka Kaplinsky(Israel), Aryeh Wiesen, Simon Bloch (Israel)
This paper proposes a model of execution platform for the
OMG request of a generic Platform- Independent-Model (PIM) allowing
realization of the Model Driven Architecture (MDA) standard. We propose
AMDA (Automata based MDA), a method based on the use of parallel
automata, which can be a common tool for building a PIM from UML
diagrams (including OCL) and transforming the PIM to PSM automata and
further to compilable code. Each platform would then have a mechanism
to execute the translated code.
Our architecture for a general PSM translator of these automata allows
portable execution on various specific implementation platforms. This
general translator must be written, once, for the languages and with
the libraries of the required specific PSM. This allows also
interoperability between different PSMs. An ATM case study example is
presented to illustrate the approach. Keywords: MDA, UML, Extended
Automata, XSLT.
An approach to ERP testing
using services
Sagi Schliesser (Israel)
Enterprise packages software solutions are becoming an
increasingly popular choice for organizations aiming to streamline
their business processes. However, as the software complexity
reaches
new heights, package vendors are faced with critical concerns regarding
quality assurance. Traditional testing methods are not designed to meet
all the challenges posed by ERP implementation. This paper will
try to
suggest a novel approach to dealing with the complexity aspects of
testing. We will try and demonstrate how the technical
advancements
introduced by SOA enable the adoption of such approach by many package
vendors. Index Terms — Software Testing, ERP testing, Software quality,
Automated Testing.
Computation
Independent Modeling within the MDA
Janis Osis, Erika Asnina
and Andrejs Grave
Object oriented analysis suggests semiformal use case driven techniques
for problem domain modeling from a computation independent viewpoint.
The proposed approach called Topological Functioning Modeling for Model
Driven Architecture (TFMfMDA) increases the degree of formalization. It
uses mathematical foundations of Topological Functioning Model (TFM)
that holistically represents complete functionality of the system. The
TFMfMDA introduces more formal analysis of a business system, namely
enables defining not what the client wants, but what the client needs,
and also enables textual functional requirement validation, missing
requirement checking in conformance with the problem domain “as is”
model. A use case model of the application is defined with the help of
a goal-based method. A domain concept model is defined by graph
transformation of the TFM. The paper also suggests an Eclipse plug-in
conception for the implementation of the TFMfMDA.
Session 1.2: Aspect-and Object
Oriented Development
Refactoring Aspects into Java Code
Michael Kleyman (Israel), Shmuel Tyszberowicz (Israel) and Amiram Yehudai (Israel)
The Agile Manifesto states
that the Agile development methodology is intended “to satisfy the
customer through early and continuous delivery of valuable software”.
One of its principles is “welcome changing requirements even late in
development”. Refactoring is a major technique used to cope with
changes. It is a process and a set of techniques to reorganize code
while preserving the external behavior. This process can be performed
automatically. Aspect oriented programming (AOP) is a powerful
technology that greatly improves programmer’s ability to quickly
introduce changes to a software system. AOP enables easily modifying
behavior of numerous locations in the system code or adding new
behavior. The AOP technology is perceived by some people not to be
mature enough, hence they avoid using it in production software. We
have developed ACME, a tool that implements a refactoring process for
aspects. ACME enables a developer to convert AspectJ code to pure Java
code according to conversion patterns. The available patterns are
creating a singleton class from an aspect and merging aspects into
existing classes. The tool creates modular and readable object-oriented
code. This paper presents ACME functionality using example
transformations and discusses the tool’s applicability and decisions
made during its design.
Assessing the Object-level
behavioral complexity in Object Relational Databases
Selwyn Justus and Ka Iyakutti (India)
Object Relational Database
Management Systems model set of interrelated objects using references
and collection attributes. The static metrics capture the internal
quality of the database schema at the class –level during design time.
Complex databases like ORDB exhibit dynamism during runtime and hence
require performance-level monitoring. This is achieved by measuring the
access and invocations of the objects during runtime, thus assessing
the behavior of the objects. Runtime coupling and cohesion metrics are
deemed as attributes of measuring the Object-level behavioral
complexity. In this work, we evaluate the runtime coupling and cohesion
metrics and assess their influence in measuring the behavioral
complexity of the objects in ORDB. Further, these internal measures of
object behavior are externalized in measuring the performance of the
database in entirety. Experiments on sample ORDB schemas are conducted
using statistical analysis and correlation clustering techniques to
assess the behavior of the objects in real time. The results indicate
the significance of the object behavior in influencing the database
performance. The scope of this work and the future works in extending
this research form the concluding note.
AspectJTamer: The Controlled
Weaving of Independently Developed Aspects
Constantin Serban (U.S.A) and Shmuel Tyszberowicz (Israel)
In recent years, Aspect
Oriented Programming (AOP) has emerged as a promising model for
modularizing large and complex programs, advancing towards wider
acceptance for mainstream commercial development. The use of AOP
techniques for developing commercial applications poses, however, a
number of challenges — especially when such applications are composed
of large numbers of binary components containing independently
developed aspects. The interaction of such independently developed
aspects with each other and with the rest of the system can lead to
unexpected problems. First, aspects in binary distributions can be
mistakenly treated as ordinary classes, thus ignoring their complex
interaction with the rest of the system. Second, independently
developed aspects might inadvertently make inappropriate assumptions
about their application environment, thus creating unintended
effects. This paper presents AspectJTamer, a tool for addressing these
issues. First, AspectJTamer provides support for identifying aspects
that are present in binary distributions and for documenting their
specific interaction points, thus making explicit both their
assumptions about, and their weaving scope within, an application.
Second, AspectJTamer provides a mechanism to control the weaving scope
of binary aspects in a flexible manner, thus offering supplemental
constraints overriding the assumptions made by independently developed
aspects.
Session 1.3: Software
Implementation
Storing a Persistent Transactional
Object Heap on Flash Memory
Nir Shasha (Israel) and Sivan Toledo (Israel)
We present the design and
implementation of two garbage collectors for TINYSTORE. TINYSTORE is a
persistent flash-based transactional memory-management system for Java
Cards. One collector is a stop-the-world collector with a traversal
ordering that is particularly efficient on flash memories. The second
is an incremental garbage collector that prevents long
garbage-collection pauses.
Execution platform for the Graphic
Real-Time Design tool of Arts'Codes
Aryeh Teitelbaum (Israel)
The Arts'Codes method is an
executable Visual Programming Language for real-time application's
development. It emerged from cognitive skills and realtime system
researches. On one hand, it molds the software design according the
natural cognitive skills, without deteriorating execution performance.
On the other hand, it proposed also a robust execution platform which
takes into account only dry technical restrictions which does not
depend on the design cognitive problems. A bridge between these two
contradictory dimensions (cognition vs. execution) was built by
defining well-defined rules for the design of an execution platform, in
order to conserve the advantages of each dimension.
Session 2.1: Software
Projects Management
Success of Open Source Projects:
Patterns of Downloads and Releases with Time
Ayelet Israeli (Israel) and Dror G. Feitelson (Israel)
The success of software
projects has many different facets: meeting user requirements, being
developed within given budget and time constraints, and actually being
used. We focus on one of them: the pattern of adoption by users and its
possible relationship with continued development. This is done based on
readily available data for open source projects, namely their releases
and downloads. Rather than just classifying projects as “successful” or
“failure”, we identify six distinct patterns of how the download rate
changes with time that illuminate different aspects of successful or
failed projects.
”You’re not thinking fourth dimensionally!” Dr. Emmett “Doc” Brown, Back To The
Future III, scene 8.
The Software Engineering Timeline:
A Time Management Perspective
Orit Hazzan (Israel) and Yael Dubinsky (Israel)
This paper addresses time
management in software development processes. The rationale for this
investigation stems from the observation that many of the problems
associated with software projects, such as planning, time pressure and
late deliveries, are time related. The analysis presented is based both
on a literature review and on illustrations of data taken from our
research on different software project management paradigms – mainly
heavyweight and agile software development.
Estimating the Required Code
Inspection Team Size
Eliezer Kantorowitz,(Israel) Tsvika Kuflik (Israel) and Alex Raginsky (Israel)
Code inspection is considered
an efficient method for detecting faults in software code documents.
The number of faults not detected by inspection should be small.
Several methods have been suggested for estimating the number of
undetected fault. These methods include the fault injection method that
is considered to be quite laborious, capture recapture methods that
avoid the problems of code injection and the Detection Profile Method
for cases where capture recapture methods do not provide sufficient
accuracy. The Kantorowitz estimator is based on a probabilistic model
of the inspection process and enables the estimating the number of
inspectors required to detect a specified fraction of all the faults of
a document as well as the number of undetected faults. This estimator
has proven to be satisfactory in inspection of user requirements
documents. The experiments reported in this study suggest that it is
also useful for code inspection.
Session 2.2: Requirements
in Practice
Derived Requirements Generation
The DRAS methodology
David Bar-On (Israel) and Shmuel Tyszberowicz (Israel)
In the early stages of system
development, many requirements interdependencies exist. Interacting
requirements may conflict with one another and they may impact (change
or enhance) other requirements as well. Those interdependencies should
be identified as early as possible in the development lifecycle.
Conflicts should be resolved, so as to avoid the cost and schedule
overhead that comes when detecting them late in the development
process. Properly identifying the interactions, during the requirements
elicitation and analysis, results in new and modified Derived
Requirements (DRs). These DRs resolve interactions and undesirable
conflicts. An important kind of requirements which interact with other
requirements is Crosscutting Functional Requirements (FRs). These
requirements change or override the function of other requirements they
crosscut, usually for certain states of product functionality. The DRAS
(Derived Requirements generation based on Actions and States)
methodology presented in this paper helps both to identify FRs that
crosscut other FRs and to generate the derived or modified
requirements. To identify crosscutting requirements, the methodology
matches actions used by requirement and the system modes and states
related to the requirements. When the same action is used by two
requirements it might indicates that one of the requirements may
crosscut the other. In addition to actions directly used, DRAS takes
into account actions implicit by them. For a specific action Act
(referred to by a requirement), DRAS uses the following
implied-actions: (a) Actions that are activated as a consequence or
result of using Act, or (b) Actions that Act is the consequence of
their use.
Context Aware Communication
Services in “Active Museums”
Sadek Jbara (Israel),Tsvi
Kuflik (Israel),Pnina Soffer (Israel) and Oliviero Stock (Italy)
Nowadays, technology enables
museums to become “active”. Shortly, museum visitors will be equipped
with smart personal devices and the museum environment can track and
interact proactively with visitors by offering them various services.
Visitors often tend to visit museums in groups, mainly with family or
friends, yet most of today's mobile museum guides focus on supporting
the individual visitor. The technologies for museum visitor guides and
other mobile guides described in various papers allow supporting
interaction between individuals or groups of visitors, since it is
known that such interaction especially in museums enhances the visit
experience. These services can be abstracted to a small subset of
context-aware communication services. The service agent developed in
the framework of the PIL project is a prototype system for a general
communication services framework.
Session 2.3: Web
Applications
Scan Objects: Adding Steering
Wheels to Search Engines
Iaakov Exman (Israel) and Alex Shnayder (Israel)
Search Engines are so powerful that they create the expectation that
search will always succeed. But interactive search is a complex
activity with significant human involvement, and very difficult to
automate. A Steering Wheel software architecture is proposed to
automate search, based upon composable and reusable entities called
ScanObjects. This architecture keeps intact the search engine power,
while adding an engine client functioning as a steering wheel. Steering
functions embodied in the ScanObjects cause search to be convergent to
desired result sets, as they obey definite convergence criteria. The
approach was demonstrated by actual implementation of the architecture
within a peer-community system, and several case studies with
well-known commercial search engines.
SOA for services or UML for
objects: Reconciliation of the battle of giants with Object-Process
Methodology
Dov Dori (Israel)
Two software system lifecycle development paradigms have been
competing on the minds and hearts of software developers and
executives: The traditional Object-Oriented approach and the emerging
Service-Oriented Architecture (SOA) or SO Development of Application
(SODA). While OO puts objects and their encapsulated behavior at the
center stage, emphasizing primarily rigid structure, SODA hails
services as the prime players to cater primarily to behavior. We
discuss the new SOA technologies from the extended enterprise and the
service network all the way to the atomic service level and show that
Object-Process Methodology (OPM), which strikes a unique balance
between structure and behavior, is most suitable as the underlying
SOA-based lifecycle engineering approach. Using OPCAT, the
OPM-supporting systems modeling software environment, we construct the
top level diagram of a model of SODA and simulate it using animation in
order to show how OPM conveniently serves as an ideal overarching
comprehensive methodology that encompasses the entire spectrum of
service-oriented enterprise systems development.
