Product Focused Software Development and Process Improvement
THEME & SCOPE
The conference themes 'professional software process improvement (SPI)',
'product focused improvement', 'collaborative' and 'agile software development'
address approaches that cover systems and software quality management and
improvement, software development applying agile principles and collaborative
software development in a global context. The themes cover both solutions and
experiences found in practice as well as research results from academia. The
conference deals with SPI extensively including quality engineering and
management topics focused on the product to be developed, thus related to
processes, methods, techniques, tools, organizations, and enabling SPI
technologies ensuring certain characteristics of the product.
The conference addresses collaborative development both as "one-roof",
"outsourced", and "offshored" development, and also deals with different
development modes, roles in the value-chain, and stakeholders' viewpoints, as
well as economic and quality aspects. Agile development is considered both as
"agile in the small" and "agile in the large". Agile development shows a
tremendous increase in productivity in one-roof development, and is considered
for being applied in large projects as well.
The conference provides a variety of up-to-date topics and tackles industry
problems. Medical, automotive, space & avionic systems, mobile applications, and
critical infrastructures are rapidly growing software application areas with a
strong need for professional development and improvement.
Nowadays,
the majority of embedded software is developed in collaboration, and
distribution of embedded software development continues to increase.
Therefore, keynote speaches, paper presentations, and discussions on the
following topics will be offered.
TOPICS
The main topics of the conference include:
* Product Focused SPI
* Systems and Software Process Improvement
* Systems and Software Quality
* SPI Methods and Tools
* Measurement
* Quality Models
* Experimental Software Engineering
* Evidence-based Software Engineering
* Industrial Experiences and Case Studies
* Process Modeling and Management
* Global Development
* Outsourcing, Nearsourcing, Offshoring
* Cultural Factors
* Agile Software Development
* Process Assessment
* Quality Standards
* SPI in Different Software Development Areas
* Cost Estimation
* Risk Management
* Best Practices
* Lessons Learned
* Organizational Learning/Experience Factory
In the domains of:
* Automotive and Transportation Systems
* Mobile Applications
* Consumer Electronics
* Telecommunications
* Embedded systems
-- 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
Quality Aware Design
Automating Test Case Design, Selection and Evaluation
Povoa de Varzim, Portugal,
17-20 June de 2009
(In conjunction with the 4th Conferencia Iberica de Sistemas y Tecnologias de la Informacion)
Trends such as globalisation, standardisation and shorter lifecycles =20 place great demands on the flexibility of the software industry. In order to =20=
compete
and cooperate on an international scale, a constantly decreasing time =20=
to market
and an increasing level of quality are essential. Software and systems =20=
testing
is at the moment the most important and mostly used quality assurance =20=
technique
applied in industry. However, the complexity of software systems and =20 hence of their development is increasing. Systems get bigger, connect large =20 amounts of components that interact in many different ways, and have constantly =20 changing and different types of requirements (functionality, dependability, =20 real-time, etc.). Consequently, the development of cost-effective and high-=20 quality systems opens new challenges that cannot be faced only with traditional =20 testing approaches.
New techniques for systematization and automation of testing are =20 required.
Even though many test automation tools are currently available to aid test planning and control as well as test case execution and monitoring, all these tools share a similar passive philosophy towards test case design, selection of test data and test evaluation. They leave these crucial, time-consuming and demanding activities to the human tester. This is not without reason; test case design and test evaluation are difficult to automate with the techniques available in current industrial practice. The domain of possible inputs (potential test cases), even for a trivial program, is typically too large to be exhaustively explored. Consequently, one of the major challenges associated with test case design is the selection of test cases that are effective at finding flaws without requiring an excessive number of tests to be carried out. This is the problem which thisworkshop wants to attack.
This workshop will provide researchers and practitioners a forum for =20 exchanging ideas, experiences, understanding of the problems, visions for the =20 future, and promising solutions to the problems in automated test case generation, =20=
selection
and evaluation. The workshop will also provide a platform for =20 researchers and developers of testing tools to work together to identify the problems =20=
in the
theory and practice of software test automation and to set an agenda =20 and lay the foundation for future development.
The First IEEE International Workshop on Middleware Engineering(ME 2009) In Conjuction with The 33rd Annual IEEE International Computer Software and Applicaiton =20 Conference
Seattle, Washington, July 20 - July 24, 2009
Workshop website: =
http://conferences.computer.org/compsac/2009/workshops/ME2009.html
Conference Website :
http://conferences.computer.org/compsac/2009/
+++++ Deadline for Paper Submissions : March 1 2009 ++++++++++
COMPSAC 2009
------------
COMPSAC is a major international forum for researchers, practitioners, =20=
managers, and policy makers interested in computer software and =20 applications.
MIDDLEWARE ENGINEERING Workshop
-------------------------------
Research in middleware systems has evolved from simple client server =20 modelsto distributed systems, peer-to-peer (P2P) systems, mobile =20 devices, service oriented computing, grid computing, agent based =20 computing, smart devices,and sensors. Each of the above areas poses =20 its own unique challenges in the design, development and deployment of =20=
middleware, its components and applications using such middleware.
The main objective of the workshop is to bring together researchers =20 and practitioners working in middleware systems with topics ranging =20 from differentareas such as distributed computing, grid computing, =20 service oriented computing, pervasive computing, P2P computing, agent =20=
based systems and sensor networks under one roof with an aim of =20 encouraging exchange of ideas and experiences among these diverse =20 communities. We solicit papers dealing with design, development and =20 deployment of middleware and its systems. We are alsointerested in =20 specific components of middleware systems, the way they interact with =20=
other modules, components design and development, models of the =20 components, middleware system issues and also novel computational =20 sciences applications using middleware systems.
TOPICS OF INTEREST
------------------
The topics include, but are not limited to:
+ Middleware for collaborative applications Middleware for agent based
+ systems Middleware for service oriented systems Middleware for mobile
+ and ubiquitous computing Middleware for computational sciences
+ applications Middleware for high performance computing applications
+ Middleware for embedded systems and sensor networks Middleware
+ solutions for Security, Privacy and Trust Middleware for distributed
+ systems including databases, P2P, and =20
grid based systems
+ Middleware issues for real time systems Software engineering
+ techniques for middleware Novel applications using middleware
+ Evaluation metrics and bench mark systems for middleware Specific
+ components of middleware such as : device discovery, =20
directory service, execution service, listening service, communication =20=
service, and data access service
Fourth ACM International Workshop on
Services Integration in Pervasive Environments (SIPE'2009) http://sipe09.conf.citi.insa-lyon.fr
at International Conference on Pervasive Services (ICPS'2009) http://acet.rdg.ac.uk/~mab/tmp/ICPS/
London, UK, July 13-17, 2008
In the last years, service-oriented computing and pervasive computing are emerging as the next computing paradigms. Service-oriented computing allows to easily develop, publish and use software functionalities. Pervasive computing rests on mobile and/or embedded devices, available anywhere and anytime, that can potentially provide services. Bringing these two trends together raises the new challenge of integrating/unintegrating, in an application, non- predefined services just discovered in the pervasive environment.
Three main sub-areas of this challenge are tackled in this workshop:
- Frameworks/Infrastructures for services integration: different developing frameworks exist and can be used or modified to ease services integration; different deployment infrastructures also exist and can be adapted to take into account the pervasive nature of the environment.
- Services interactions: allowing non-predefined services to interact implies to have "smart" and adaptive matching and communication mechanisms.
- Dynamic combining of services: because pervasive environments are highly dynamic, the integration of services needs to be aware of context changes to choose the more appropriate combining/deployment techniques.
Topics of interests (but not limited to)
----------------------------------------
- Developing frameworks for services integration
- Deployment infrastructures for services integration
- Semantic services discovery and matching
- Adaptive communication protocols for pervasive services
- Context-aware integration
- Aspect-oriented approaches in pervasive environments
- Services composition and choreography in pervasive environments
- Integration strategies
- Monitoring and management of services integration
- Contracting and negotiating approaches of integration
- Ontologies of integration
- Secure pervasive integration
- Business integration approaches for pervasive services
- Enterprise service integration
- Autonomic integration
Special issue
Ontology, Conceptualization, Epistemology and Knowledge Engineering for Service Science, Information Systems and Software Engineering
International Journal of Software Engineering and Knowledge Engineering
(IJSEKE)
<http://www.worldscinet.com/ijseke/ijseke.shtml>
http://www.worldscinet.com/ijseke/ijseke.shtml
Organized by members of the ONTOSE Workshop series (this year collocated with CAISE):
<http://conf.ifit.uni-klu.ac.at/ontose/>
http://conf.ifit.uni-klu.ac.at/ontose/
Aims, Scope and Topics
---------------------------------
In our society which has already turned to a service-providing =20 society, the technical aspects as well as the human, social and economic aspects =20 must be considered together. This has already resulted in considerable =20 research on these aspects that are related to disciplines as Information Systems =20 (IS), Software Engineering (SE) and more recently Service Science (SS). =20 Service Science, Management and Engineering (SSME) or Service Science (SS) is an emerging academic discipline designed to develop the skills required =20 in the world's increasingly service-based economies. This new field will bring together ongoing work in computer science, operations research, =20 industrial engineering, business strategy, management sciences, social and =20 cognitive sciences, and legal sciences. SS connects with IS and SE as the latter disciplines deal with the arrangement of information and software that =20=
is
essential to a variety of service-providing organizations today. In consequence, the examination of ontological, conceptual, =20 epistemological and engineering issues connecting these disciplines require a multi-=20 disciplinary viewpoint.
Topics related to ontological and epistemological issues in IS, SS and =20=
SE
include for example how empirical research should be conducted, what =20 are the conditions for "valid" knowledge, which models and entities are =20 essential to the discipline, and which the scope of theories in these fields are. =20 These are elements are of interest from perspectives as diverse as philosophy, engineering and information technology. For example, the material and temporal entities that are dealt with in these fields are a matter of ontology, and the conditions for credibility of statements and research methods are a matter of epistemology. Hence the relationship and =20 influences between software, software processes, information systems and service science must be studied from an ontological view point, but with a broad perspective under which researchers with different background can meet together and truly multi-disciplinary issues can arise. Further, the =20 broad applied discipline of knowledge engineering supports the formalization =20=
of
the underlying models, making these models useful and actionable through software tools.
The representation of entities, statements and models in IS, SE and SS =20=
share
common aspects in notions as process, service or value. SS has strong =20=
links
with Software Engineering since complex service systems in many cases =20=
need
to be supported by software and software processes that are flexible =20 enough to adapt to the design of service offerings. It also has connections =20 with Information Systems as a research area, since services are the front =20 stage of virtually any kind of business today, and most of theses businesses =20=
and
organizations are supported by an explicitly designed Information =20 System.
The main goal of this special issue is to allow challenging and =20 promising cross-fertilization over the multidisciplinary research areas that =20 comprise the conceptual, ontological and epistemological issues of the =20 disciplines of SS, IS and SE. Contributions bridging several of the disciplines or =20 covering aspects of more than one of them are especially encouraged.
Topics therefore include (but are not limited to) the following:
=B7 Ontology and formal ontology representations of SE, SS and IS.
=B7 Knowledge representation and reasoning related to SE, SS and IS
=B7 Studies and essays about metrics, indicators and general issues regarding research on Services and Systems Engineering.
=B7 Conceptualizations, bodies of knowledge or schemas for SS, SE or IS.
=B7 Social, psychological and organizational systemic issues about the disciplines.
=B7 Epistemological and philosophical aspects of service development and their supporting software-related processes.
=B7 Architectural patterns, ontologies and knowledge representations for the design of high-quality services.
=B7 UML and other modelling frameworks for services combined with IS and and SE.
=B7 Ontologies in requirements engineering, intensional and goal modelling in the context of services.
=B7 Ontology driven development of service software, or knowledge-based representations supporting service provision or service-related =20 processes.
=B7 Knowledge representation and models related to SS.
=B7 Conceptual models and representations of concerns cross-cutting SE, IS and SS.
Workshop Description
------------------------------
Software evolution and adaptation is a research area in continuous evolution, and offering stimulating challenges for both academic and industrial researchers.
The evolution of software systems, to face unexpected situations or just for improving their features, relies on software engineering techniques and methodologies. Nowadays a similar approach is not applicable in all situations e.g., for evolving nonstopping systems or systems whose code is not available.
Features of reflection such as transparency, separation of concerns, and extensibility seem to be perfect tools to aid the dynamic evolution of running systems. Aspect-oriented programming can simplify code instrumentation whereas techniques that rely on meta-data can be used to inspect the system and to extract the necessary data for designing the heuristic that the reflective and aspect-oriented mechanism use for managing the evolution.
We feel the necessity to investigate the benefits brought by the use of these techniques on the evolution of object-oriented software systems. In particular we would determine how these techniques can be integrated together with more traditional approaches to evolve a system and the benefits we get from their use.
This workshop can be a good meeting-point for people working in the software evolution area, and an occasion to present reflective, aspect- oriented and data mining based solutions to evolutionary problems, and new ideas straddling these areas.
Workshop Topics
------------------------
Particularly interesting for this workshop are works that focus the static or dynamic evolution of software systems. Techniques may vary to achieve this goal. In particular, they include but are not limited
to:
- adaptative software components and evolution as component composition;
- aspect-oriented middleware and environments for software evolution;
- evolution planning and deployment through aspect-oriented and reflective approaches;
- aspect interference and composition for software evolution;
- feature- and subject-oriented adaptation;
- unanticipated software evolution supported by AOSD or reflective techniques;
- MOF, code annotations and other meta-data facilities for software evolution;
- software evolution tangling concerns;
- metrics and other evaluation mechanisms to evaluate the impact of using reflection and/or AOP to get software evolution;
- AOP and reflection based design patterns to get software evolution;
- early aspect evolution, i.e., to design evolution by evolving the design information or the application in its early stages of development;
Mutation 2009: The 4th International Workshop on Mutation Analysis April 4, 2009, Denver, Colorado, USA
http://mutation2009.ist.tugraz.at/
Co-located with ICST 2009 (2nd International Conference on Software Testing, Verification and Validation)
We would like to heartily invite you to participate in the 4th International Workshop on Mutation Analysis. For registration details please visit the ICST 2009 website:
http://bitterroot.vancouver.wsu.edu/icst2009/
About Mutation 2009:
--------------------------------
Mutation is acknowledged as an important way to assess the fault-finding effectiveness of tests sets. Mutation testing has mostly been applied at the source code level, but more recently, related ideas have also been used to test artifacts described in a considerable variety of notations and at different levels of abstraction. Mutation ideas are used with requirements, formal specifications, architectural design notations, informal descriptions (e.g. use cases) and hardware. Mutation is now established as a major concept in software and systems V&V and uses of mutation are increasing. The goal of the Mutation workshop is to provide a forum for researchers and practitioners to discuss new and emerging trends in mutation analysis.
Platforms for Analysis, Design and Verification of Embedded Systems
Even after many years of work on unifying modelling frameworks, it is still the case that for a complex system, different models are built for different purposes. For example, a design model and a model for =20 performance analysis are built by different people, with different tools, and using different paradigms. This means that different aspects of a system are =20=
defined
by different models corresponding to different "views" of the system. =20=
The
resulting collection of views should be structured, that is the =20 semantics of each of these views related in order to form a complete specification =20=
of the
system to be implemented or validated. Central related questions are =20 defining and checking consistency: does the complete specification =20 characterizes at least one valid system? how can this be verified? preferably without =20 computing a global model, and how that consistency is preserved by the design cycle operations, such as refinement or composition? In addition, due to the heterogeneous nature of embedded systems, in the sense that they involve mechanical/hardware/software parts, different modeling paradigms and =20 tools are used for modelling different parts of the system, as different =20 paradigms are well adapted or accepted by the respective user community. Also here, =20=
the
challenge is reasoning on the composition of models of heterogeneous =20 nature using either different tools or a tool offering the capability to =20 unify very different paradigms without too much loss of abstraction.
* A related challenge is how reconcile early - speculative - =20 validation of non functional, platform related properties without imposing unnecessary partition constraints which turn out to be badly chosen at later =20 design stages.
* The introduction of new paradigms for designing specific classes of embedded systems and the trend towards adaptive, self-organizing, self-=20=
healing,
systems poses new challenges for the verification of embedded systems =20=
which in
the past has been mainly of static nature
* The increasing complexity, heterogeneity and ubiquity of embedded =20 systems leads to the emergence of new non functional properties for which =20 appropriate models and verification methods have to be developed. This is partly =20 addressed by the verification community, but the interaction between the design =20=
approaches
and the verification techniques are rarely studied.
* Increasingly, embedded systems are conceived as service oriented =20 systems where it should be possible to plug in new functionalities with a =20 reduced effort. This lead to the definition of component concepts which differ =20=
from
those used in pure functional or object oriented languages. Exploiting =20=
such
concepts for achieving designs which are both more flexible and easier =20=
to verify
remains a challenge. In particular such component based systems are =20
=93complex=94 in
the sense that the whole system may question properties of its sub =20 components, resulting on the emergence of system properties that could not be =20 deduced by reasoning on each component taken in isolation. This makes classical =20 and well studied modular reasoning difficult. Different notions of contracts =20 have been studied to address this issue.
Therefore, the workshop focuses on the integration of tool supported =20 analysis and validation techniques into a development process in the domain of =20=
embedded
systems. It is expected that the submitted contribution handle about =20 model-based approaches for the development of embedded systems with respect to the problematic of their validation or tools or case studies on the =20 integration of existing validation methods into design flows used in practice.
We consider a spectrum of topics related to the design of platforms =20 for building functionally correct embedded and complex systems with guaranteed =20 properties.
* Paradigms for designing specific classes of embedded systems and challenges for verifying non functional and platform related =20 characteristics
* Validation of complex architectures and system level analysis. This includes handling heterogeneity and multi-views from design to =20 validation or verification.
* Representations for systems, their platforms and their properties allowing their efficient exploitation by validation and code =20 generation tools
* Platforms for integrating validation and development: challenges and solutions
* Solutions for tool integration
* Adapting validation techniques to the type of functional/non =20 functional properties under study
* Studying emergence of properties in complex embedded systems
The Third IEEE International Conference on Cloud Computing (CLOUD 2010)
July 5-10, 2010, Miami, Florida, USA
Sponsored by the Technical Committee on Services Computing (IEEE Computer Society), the Third IEEE 2010 International Conference on Cloud Computing (CLOUD 2010) will be co-located with the 6th IEEE 2010 World Congress on Services (SERVICES 2010), the 8th IEEE 2010 International Conference on Web Services (ICWS 2010), and the 7th IEEE 2010 International Conference on Services Computing (SCC 2010) to grow itself to continute to be the most prestigious professional conference dedicated to cloud computing.
"Change we are leading" is the theme of CLOUD 2010. Cloud Computing has become a scalable services consumption and delivery platform in the field of Services Computing. The technical foundations of Cloud Computing include Service-Oriented Architecture (SOA) and Virtualizations of hardware and software. The goal of Cloud Computing is to share resources among the cloud service consumers, cloud partners, and cloud vendors in the cloud value chain. The resource sharing at various levels results in various cloud offerings such as infrastructure cloud (e.g. hardware, IT infrastructure management), software cloud (e.g. SaaS focusing on middleware as a service, or traditional CRM as a service), application cloud (e.g. Application as a Service, UML modeling tools as a service, social network as a service), and business cloud (e.g. business process as a service).