Product Focused Software Development and Process Improvement

-- Models and Aspects - Handling Crosscutting Concerns in MDSD --

Both, Model-Driven Software Development (MDSD) and Aspect-Oriented Software Development (AOSD) are considered important new paradigms in modern software engineering.

While the two approaches are

different in many ways - MDSD adds domain-specific abstractions, while AOSD is currently primarily seen as an implementation technique - they also have many things in common - for example they both have a query phase followed by a construction phase. But more importantly, we think that it is useful to use both techniques in combination. Two examples for combining MDSD with AOSD could be aspect-oriented modeling combined with code generation, or the generation of pointcuts for AO languages from a domain model.

Potential topics include, but are not limited to:

- handling crosscutting concerns in modeling

- aspect weaving in models

- measuring the maintainability benefits of models and aspects

- using models to overcome the fragile pointcut problem

- case studies that show the benefits of models and aspects

Enterprise Information Systems

WEISE

-------------------------------------

Enterprise Information Systems Engineering develops the methodologies and technologies to represent, design, implement, analyze and maintain the several aspects of enterprise information systems. The intricate relationships between business strategy, or-ganizational structure, business processes and information systems require enterprises to resort to powerful modeling tools in order to represent and trace those dependencies in an accurate blueprint. They also require methods and techniques to turn blueprint into practice by means of predictable, controlled implementation patterns that promote and preserve organization self-awareness throughout. As it encompasses multi-disciplinary topics such as business process modeling, enterprise information modeling, enterprise ontologies, enterprise architectures and service-oriented architectures, Enterprise Information Systems Engineering aims at consolidating these technologies into a holistic framework for developing and operating information systems within and across organizations.

The 2nd International Workshop on Enterprise Information Systems Engineering (WEISE) held in conjunction with DEXA provides an opportunity for researchers and practitioners alike to openly discuss current practices, identify critical issues, and lay the foundation for continuing developments in this area.

Topics

-------------------------------------

Topics of interest include, but are not limited to the following areas:

* Enterprise information systems modeling, analysis and design.

* Enterprise frameworks and architecture.

* Enterprise modeling languages and standards.

* Enterprise ontology and semantics.

* Business process management.

* Business process modeling and design.

* Business process mining, discovery and analysis.

* Method engineering and reference modeling.

* Frameworks for enterprise information systems cooperation, interoperability and integration.

* Service-oriented enterprise architecture.

* Enterprise information systems research, methodologies and theoretical foundations.

* Case studies and applications.

AI in Software Engineering

Machine Learning (Unsupervised & Supervised learning)

Text Mining & Retrieval

Probabilistic Reasoning

Model Learning

Expert Systems

Neural Networks

Data Mining

Evolutionary algorithms

Ranking Algorithms

in

Software Requirements

Software Architecture

Software Methodologies

Software Algorithms

Software Design

Software Performance Engineering

Software Quality

Software Reliability

Object-Oriented Analysis and Design

Software Maintenance

Software Testing

Software Metrics

Software Project Management

Software Cost Estimation

Open Source Software

Software Repository Management

Workshop on Automated

Specification and Verification

 SCOPE

 The increased complexity of Web sites and the explosive growth of

Web-based applications has turned their design and construction into

a challenging problem. Nowadays, many companies have diverted their

Web sites into interactive, completely-automated, Web-based

applications (such as Amazon, on-line banking, or travel agencies)

with a high complexity that requires appropriate specification and

verification techniques and tools. Systematic, formal approaches to

the analysis and verification can address the problems of this

particular domain with automated and reliable tools that also

incorporate semantic aspects.

We solicit original papers on formal methods and techniques applied

to Web sites, Web services or Web-based applications, such as:

* rule-based approaches to Web site analysis, certification,

specification, verification, and optimization

* formal models for describing and reasoning about Web sites

* model-checking, synthesis and debugging of Web sites

* abstract interpretation and program transformation applied

to the semantic Web

* intelligent tutoring and advisory systems for Web specifications

authoring

* Web quality and Web metrics

* Web usability and accessibility

* Testing and evaluation of Web systems and applications

Aspects, Dependencies and Interactions (ADI 2008)* Harnessing the diversity of approaches to interaction resolution Affiliated to ECOOP 2008, July 7 - 11, Paphos, Cyprus

Interaction problems between different modules, program parts or units of specifications are a central challenge to many program structuring paradigms, including Aspect-Oriented Software Development, feature-based programming and component- based software engineering. Furthermore, interaction problems are relevant to all phases of the software development life

cycle: from requirements through to implementation and often exert a broad influence on these concerns, e.g. by modifying their semantics, structure and / or behavior. Such dependencies often lead to both desirable and unwanted or unexpected behaviors of large-scale applications.

This workshop is focused on identifying, understanding, and resolving all kinds of issues related to such dependencies and interactions, by bringing together researchers and practitioners from across the whole spectrum of software development activities and methodologies.

We encourage submissions investigating the problems of such dependencies and interactions and handling them at all levels:

- starting from the early development stages (i.e., requirements, architecture, and design), looking into dependencies between requirements (e.g. positive / negative contributions between aspectual goals, etc.) and interactions caused by aspects (e.g. quality attributes) in requirements, architecture, and design;

- analyzing these dependencies and interactions both through modeling and formal analysis;

- considering language design issues which help to handle such dependencies and interactions;

- studying such interactions in applications.

*Goal of the workshop* is to continue the wide discussion on aspects, dependencies and interactions, started at ADI 2006 and continued at ADI 2007, thus investigating the lasting nature of such dependency links across all development activities. It is hoped that input from both research and practice will help to progress the understanding and solutions to this complex subject.

*Topics of interest* include, but are not limited to:

- Evaluation or definition of interaction analyses and corresponding resolution methods that harness methods and techniques from different research fields;

- Requirements, architecture, design, and language level techniques and mechanisms for interaction/dependency detection and/or resolution;

- Interaction classification, types of dependencies and interactions;

- New methods and techniques for the analysis and resolution of interactions;

- Methods for the formal representation and analysis of dependencies and interactions;

- Mechanisms for interaction detection and handling in domain-specific languages;

- Interaction detection and analysis in specific applications (e.g. middleware for pervasive and mobile systems, security applications, persistence management, etc.);

- Tool support for any of the above;

- Case studies of practical interactions.

Software Engineering for REsilieNt systEms

The SERENE 2008 workshop is an international forum for researchers

and practitioners interested in the advances in Software Engineering

for Resilient Systems. SERENE 2008 views resilient systems as open

distributed systems that have capabilities to dynamically adapt,

in a predictable way, to unexpected and harmful events, including faults

and errors. Engineering such systems is a challenging issue which needs

urgent attention from and combined efforts by people working in various

domains. Achieving this objective is a very complex task, since it

implies reasoning explicitly and in a consistent way about systems

functional and non-functional characteristics.

SERENE advocates the idea that resilience should be explicitly included

into traditional software engineering theories and practices and should

become an integral part of all steps of software development. As current

software engineering practices tend to either capture only normal 

behaviour,

or to deal with all abnormal situations only at the late development

phases, new software engineering methods and tools need to be developed

to support explicit handling of abnormal situations through the whole

software life cycle. Moreover, every phase of the software development

process needs to be enriched with the phase-specific resilience means.

SCOPE:

The following constitutes a list of the key software engineering domains

that the SERENE workshop will focus on. This list should not, however,

be considered as closed or technically restrictive:

- Formal and semi-formal modelling of resilience properties

- Re-engineering for resilience

- Software development processes for resilience

- Requirement engineering processes for resilience

- Model Driven Engineering of resilient systems

- Verification and validation of resilient systems

- Error and fault handling in the software life-cycle

- Resilience through exception handling in the software life-cycle

- Frameworks and design patterns for resilience

- Software architectures for resilience

- Component-based development and resilience

- System structuring for resilience

- Atomic actions

- Dynamic resilience mechanisms

- Resilience prediction

- Resilience metadata

- Reasoning and adaptation services for improving and ensuring 

resilience

- Intelligent and adaptive approaches to engineering resilient systems

- Engineering of self-healing autonomic systems

- Dynamic reconfiguration for resilience

- Run-time management of resilience requirements

- CASE tools for developing resilient systems

Synchronous and Asynchronous Interactions in Concurrent Distributed Systems

Interaction and Concurrency Experiences (ICEs) is intended as a series

of international scientific meetings oriented to researchers in

various fields of theoretical computer science. The timeliness and

novelty of these events relies both on the variety of the topics that

will be treated on each event and on the adopted paper selection

mechanism.

Every experience will focus on a different specific topic which

affects several areas of computer science; A thorough scientific

debate among PC and authors of submitted papers will parallel the

reviewing process; After the paper selection phase, papers will be

published on the web and the discussion will be extended to

perspective participants.

-- Scope --

The scope of this first experience is to include theoretical and

applied aspects of interactions and the synchronization mechanisms

used among actors of concurrent or distributed systems. The workshop

intends to attract researchers interested in models, verification,

tools, and programming primitives concerning such complex

interactions.

Synchronisation mechanisms are one of the key aspects in concurrency

and they are becoming enormously relevant in modern distributed

systems. Theoretical models, design and verification of interaction

protocols and programming practice must take synchronisations into

account for specifying, implementing and reasoning on systems where

computations are spread across possibly many actors that interact

within a precise interaction framework.

At a low level of abstraction, systems can be classified according to

a wide spectrum, ranging between the two extremes of (completely)

synchronous or asynchronous interactions. In fact, such a

classification can be given according to the assumptions made on,

e.g., the number of participants or the time interactions need to be

effected. Significantly, the behaviour of such systems can be

investigated using different assumptions that yield different

expressiveness or complexity results.

Several recent theoretical results shed light on the interrelations

between synchronous and asynchronous interaction mechanisms (e.g.,

expressiveness results for distributed algorithms, relations among

observational semantics of synchronous models). Interaction

mechanisms have also been studied in relation to other features of

systems such as mobility (e.g., name passing process calculi,

graph-based models).

-- Topics --

Topics of interest include, but shall not be limited to:

- models, logic and types for interactions;

- synchronous/asynchronous mechanisms;

- expressiveness results;

- timed and hybrid interactions;

- verification, analysis and tools;

- programming primitives for interactions;

- interactions as coordination mechanisms;

- interactions inspired by emerging computational models (systems

biology, quantum computing, etc.).

Object-Oriented Software Development for the Embedded World

Overview

The purpose of this workshop is to bring hardware and software 

communities

closer together in order to explore the current and future challenges in

application development and integration in different embedded system

domains. We wish to examine software engineering technologies for

addressing those challenges, without neglecting the often stringent

constraints imposed by hardware.

Description

New challenges arise in embedded software development in addition to the

traditional ones of power efficiency, memory usage and execution time.

Productivity, and thus time to market, become serious issues

due to the shift at the application level and new developments at the

hardware level, for example:

- several interactive or dynamic applications, often from different 

vendors,

have to be mapped to multi- or even many-core processor architectures

- distributed applications have to run on a number of devices

such as regular PCs, nomadic battery-operated consumer devices, and/or

programmable sensors

- device mobility and hardware failure, e.g. due to sub 32 nm

technology, make unreliability the rule rather than the exception

In traditional software engineering the application-level problems are

far from

new: numerous approaches deal with application integration,

higher-level languages and tools improve productivity, tried-and-true

software architectures exist for distributed applications, and so on.

Nevertheless, the very nature of embedded systems imposes additional

constraints on objectoriented software development. One of the most

stringent constraints continues to be resource efficiency,

especially with respect to power consumption. The central question of 

the

workshop will be how we can adapt and transfer the knowledge in

object-oriented software development to address these issues in embedded

systems.

Topics of Interest

Topics of interests include, but are not limited to:

- assessing and dealing with limited performance, limited amounts of 

memory,

and the requirement of minimal power consumption prevalent in

resource-constrained

embedded devices on object-oriented technologies;

- virtual machines and runtime architectures for

object-oriented languages for embedded systems;

- object-oriented language features for embedded devices;

- supporting heterogeneous architectures of embedded devices

(combining a CPU with a DSP, for example) with object-oriented 

technology;

- dealing with adaptability, heterogeneity and mobility in embedded 

devices;

- software techniques and tools for optimizing code for embedded 

devices;

- object-oriented operating systems for embedded devices;

- resource-aware computing.

Model-based Testing

Background

----------

Costs entailed by software failures demonstrate that the systematic

development of software in a certain quality is still a challenge, even

after decades of research. A reason for this can certainly be found

within the single projects. Often, known techniques of quality

assurance are not employed as required due to deadline and budget

restrictions. However, another reason is also the lack of techniques

for quality assurance for specific types of software and software

developed according to specific programming and modeling techniques.

Testing is one of the important analytical techniques of quality

assurance. In model-based testing, the software under test is considered

by the means of a model that focuses on certain aspects, often on the

behavior of the software under test. Models frequently used are finite

state machines and flow graphs. Testing techniques based on such models

are, for instance, formal verification, control and data flow analysis,

and also model checking.

This workshop aims at giving researchers and practitioners a platform

to present their results and experience to a broader audience.

The topics of interest include, but are not limited to:

* Models and modeling notations for programming and testing

* Test case generation based on formal and semi-formal models

* Test coverage metrics and criteria for model-based testing

* Model-based verification and validation

* Models as test oracles, test validation with models

* Formal methods and theories in model-based testing

* Application of model checking in testing

* Simulation by models, forecasts of behavior and properties by models

* Model-based testing of reactive and object-oriented systems

* Model-based verification and validation of tests

* Testing with software usage models

* Tools for model-based testing

* Experience reports and requirements from model-based testing in

practice

* Experience reports from model-based testing and model-based

development in practice

Applications and Advances in Problem Frames

DESCRIPTION

  It is our pleasure to invite you to participate in the

ICSE co-located Third International Workshop on Applications and

Advances of Problem Frames - IWAAPF'08.

Michael Jackson's Problem Frames are a highly promising approach to

early life-cycle software engineering. Their focus moves the engineer

back to the problem to be solved rather than forward to the software

and solving a poorly defined problem. The influence of the Problem

Frames approach and related work is spreading in the fields of domain

modelling, business process modelling, requirements engineering,

software architecture as well as software engineering in general. The

3rd International Workshop on Advances and Applications of Problem

Frames will continue the success of IWAAPF'04 and IWAAPF'06, held at

ICSE'04 and ICSE'06, respectively.

There are 14 excellent papers to be presented and discussed at the

workshop this year. Some describe work completed and others work in

progress. There are variants of Problem Frames, ontologies for Problem

Frames, and the continuing work on taking Problem Frames closer to the

solution space and more traditional software engineering techniques.

Service-Oriented Architecture (SOA) is having a substantial impact on the way software systems are developed. Although significant progress is being made in several fronts, there is not a set of clear, central themes to focus research activity. As a result, there is a danger that important research needs will be overlooked, while other efforts will focus on issues of peripheral long-term significance in practice. This workshop will refine the SOA Research Agenda that was developed by SEI and an international team in 2007 and will follow up on the 1st SDSOA workshop held at ICSE 2007.

At SDSOA 2007, the following topics were identified by the attendees as challenge areas in SOA-based systems development

* Techniques for the integration and composition of services in an SOA environment

* Service Level Agreements (SLAs) in an SOA context

* Migration of systems to SOA environments

* Design and validation of properties/service qualities in SOA-based systems

* Economics of SOA: cost to build a service vs. revenue that can be generated by a service

* Managing SOA-based systems in the context of the software life cycle

* Analysis of business processes and their relationship to runtime services

* Challenges of SOA-based systems engineering vs. traditional software engineering

* Distributed computing concepts and their application in a SOA context

* Role of semantics in SOA-based systems

* Runtime monitoring and adaptation in SOA-based systems

* Role of education: how to teach the skills that are necessary in SOA environments

Cell Systems

  The increasing needs of present and future computation-intensive

applications have stimulated research in new and innovative approaches

to the design and implementation of high-performance computing

systems.  At the same time, adoption of compute-intensive techniques

in the embedded and consumer space offers new challenges in the areas

of heat and temperature dissipation, integration, packaging and system

cost.

  The Cell Broadband Engine answers the multiple challenges on

increased performance and integration and reduced system cost and

power dissipation by presenting an integrated system architecture

based on a heterogeneous chip multiprocessor with accelerators. Papers

are sought on theory, methodologies, technologies, and implementations

concerned with innovations in heterogeneous system architectures,

computing paradigms, computational models, architectural paradigms,

computer architectures, development environments, compilers, operating

environments and in particular libraries and applications. Papers are

solicited in, but not limited to, the following areas:

* Application porting and tuning for Cell BE architectures

* Acceleration middleware and non-numeric acceleration

* Programming languages and programming models for heterogeneous systems

* Exploiting explicitly managed memory hierarchies in applications

* Data management and blocking for local stores

* Architecture improvements for heterogeneous architectures and

    explicitly managed memory hierarchies 

* Use of consumer embedded devices for computational grids

* Virtualization and virtual machines for heterogeneous architectures

* Compilers and operating systems

* Workload characterization of emerging applications and their performance

    on heterogeneous architectures

* Traditional and emerging high-performance applications

* Supercomputing and adaptation, porting and tuning of scientific libraries

    for Cell systems

* Using accelerator-based architectures to accelerate managed runtime

    environments

* Novel system architectures based on the Cell BE

* Computational biology