http://www.cs.vassar.edu/faculty/welty/ase/
http://www.softwaredioxide.com/
·
Analysis and design methods
·
Concurrent, real-time,
parallel systems
·
Databases and object
persistence
·
Patterns
·
Methodologies for
agent-oriented analysis and design
·
Distributed and mobile object
systems
·
Frameworks and software
architectures
·
Language design and
implementation
·
Object testing and metrics
·
Programming environments
·
Metaprogramming
·
Separation-of-Concerns
Programming
·
Reflection, adaptability,
composability and reusability
·
Theoretical foundations
·
Methods for defining and
isolating aspects are essential to the engineering
·
of small to large-scale
software systems. Examples of aspects include debugging,
·
logging, coordination,
fault-tolerance, synchronization and security (access
·
control/capability) which in
non aspect-oriented programming techniques
·
may produce applications that
are hard to maintain, understand and evolve
· to meet future requirements.
Aspect-Oriented Software
Development (AOSD) is an emerging technology that
·
provides direct support for
separating and weaving concerns that crosscut
·
the functional components in
a typical software system. AOSD provides various
·
mechanisms to express, adapt,
isolate and reuse crosscutting concerns in
·
the software development.
Research in AOSD is reaching maturity with a number
·
of active research products.
The Communication of the ACM October 2001 issue
·
and the web site http://www.aosd.net
are an excellent starting point to
·
learn about the many software
efforts being conducted in this exciting new
·
research area.
·
The ultimate goal of this
session is to bring users and researchers together
·
to present work related to
AOSD and those who want to learn about AOP and
·
techniques for separating
crosscutting concerns in the software development.
·
The session will thus present
opportunities for discussing further evolutions
·
and their expected benefits.
·
Selected papers may be
published in a special issue journal
·
Topics of Interest
·
The scope of this Session
encompasses but is not limited to:
A.
Technological
Support for AOSD
§
A.Programming languages
design and implementation.
§
B.Programming environments
and development tools.
§
C.Reflection and Meta
programming.
§
D.Aspect-oriented middleware.
§
E.Design languages and
notations
§
F.Design heuristics and
architectural/design patterns
B.
Formal
Methods and Verification
§
A.Conflicting concerns:
detection and means for composition
§
B.Consistency management
between concerns
§
C.Formalization of Aspects
and weaving
§
D.UML related proposals to
support aspect-orientation
C.
Software
Development Process
§
A.Software architecture,
evolution and reuse
§
B.Risk, cost and quality
management
§
C.Frameworks for AOSD.
§
D.Aspect-oriented modeling
and automated code generation
D.
Experience
Reports
§
A.Experience with AO
languages and weaving tools
§
B.Experience with CASE tools
for AOD/Paper Submission Guidelines
·
For more information:
·
http://www.iit.edu/~concur/EVENTS/AOSD1.html
Open Software Systems
http://sern.ucalgary.ca/~maurer/ICSE99WS/Submissions/Cubranic/Cubranic.html
·
In May 2001, “Making Sense
of the Bazaar: The 1st Workshop on Open
·
Source Software
Engineering” was held at the 23rd International
·
Conference on Software
Engineering (ICSE 2001) in Toronto, Ontario,
·
Canada. Since then, interest in Open Source Software (OSS) has
·
continued to gain momentum,
both in the practitioner and research
·
communities. The goal of this year’s workshop is to bring together
·
researchers and practitioners
to discuss both the short and long term
·
sustainability of OSS.
Specifically, the workshop will seek to
·
address the quality and
maintainability of OSS products and tools,
·
the replicability and
portability of the OSS software engineering
·
process and tool kit, the
stability and sustainability of OSS
·
developer and user
communities, and the viability and profitability
·
of OSS business models.
·
The discussion will be
organized around four key themes:
1.
The
quality and maintainability of OSS products.
This includes,
·
but is not limited to, the
reliability, availability, security,
·
and usability of OSS products
and tools; the architectural
·
characteristics of OSS
products and tools; and the current and
·
future roles played by OSS
products and tools in different
·
application spaces.
Of particular interest is the phenomenon of
·
“boot-strapping”, i.e.,
the role of OSS software (both existing and
·
potential) in the development
of OSS software.
2.
The
replicability and portability of the OSS software engineering
·
process and tool kit. This
includes, but is not limited to, dialogue
·
and knowledge transfer
between OSS and traditional software
·
engineering approaches and
tool use; comparisons between OSS and
·
other methods of software
engineering; and the extent to which
·
traditional software
developers are able to effectively adopt OSS
·
tools and techniques.
3.
The
stability and sustainability of OSS developer and user
·
communities. This includes, but is not limited to, the
·
community-based management of
knowledge, reputation and trust;
·
mechanisms and practices for
effective collaboration; and comparisons
·
between company-led (or
company-enabled) OSS development teams and
·
emergent, volunteer
communities.
4.
The
viability and profitability of OSS business models. This
·
includes, but is not limited
to, the sustainability of pure-play OSS
·
business models; the
emergence of hybrid proprietary-OSS business
·
models; and the impact of
intellectual property law on OSS.
·
PEER TO PEER COMPUTING
·
Peer-to-peer computing has
recently gained
popularity thanks
to the
·
emergence of file
sharing applications
over the
Internet. In
a
·
peer-to-peer system, users are at
the same time users and providers
of
·
information, which
is usually exchanged
through pairwise
·
interactions. Moreover, peers
may come and go, and yet the
system retains
·
the ability to
query the currently available peers
for information. This
·
change of perspective,
that sets
peer-to-peer computing
apart from
·
traditional client-server
computing, holds the potential
for beneficially
·
impacting a number
of factors,
including the flexibility and
·
reconfigurability of
the overall system, its scalability,
and the privacy
·
and anonymity
of the users. Moreover, the exploitation of
a peer-to-peer
·
paradigm is not necessarily
constrained to the
domain of Internet file
·
sharing. Indeed, the
aforementioned advantages are likely to exist also for
·
applications in the
enterprise environment, where
peer-to-peer systems may
·
radically change the
way information
is exchanged
and collaboration
·
activities are performed.
·
Although the concept of
peer-to-peer computing is
far from new,
its
·
application to modern
distributed computing systems and applications brings
·
in new problems and research
challenges. For instance, how to discover new
·
peers appearing
in the system? How to
route information searches
across
·
such a fluid environment? How
to guarantee security properties? Hence, the
·
research issues involve
several areas,
including networking protocols,
·
distributed algorithms,
middleware and software architectures, coordination
·
models, security. Interestingly,
the highly dynamic
environment set by
·
peer-to-peer computing
shares several problems with mobile
computing, and
·
in
particular with
ad hoc networking,
where the
absence of a
fixed
·
networking infrastructure mandates
peer-to-peer interactions between
the
·
mobile hosts. For
this reason, the workshop will devote
special attention
·
to contributions that exploit
the potentiality of the peer-to-peer paradigm
·
in a mobile setting or
analyze the possible synergies of these two areas.
·
This workshop
aims at bringing together researchers and
practitioners in
·
the field of peer-to-peer computing, with the goal of assessing the state
·
of the art and of identifying the fundamental open issues in the research
·
field.
·
** AREAS OF INTEREST
·
Contributions
are sought
regarding any
research issue
specific to
·
peer-to-peer computing, spanning
from theoretical
aspects to
system
·
implementation.
·
Hence, topics include, but
are not limited to:
·
middleware and architectures
·
security and privacy
·
algorithms and protocols for
peer discovery and for routing searches
·
sharing and coordination
abstractions and models
· experience reports
Patterns
http://www.cos.ufrj.br/~sugarloafplop/
SUBMISSIONS DUE: 31 MAR 2002
DASC (digital avionics systems conference)
flight critical systems, health monitoring, aging aircraft /
retrofit, situation displays and synthetic vision, intelligent systems,
system engineering, open systems, and software engineering -- and papers discussing the application of avionics to a variety of domains, including spacecraft and satellites, general aviation, and uninhabited air vehicles / missiles. In addition, the theme of this DASC will focus on Air Traffic Management for Civilian and Military Systems, with tracks devoted to ATM concepts, demonstrations and evaluations, and Communication, Navigation and Surveillance (CNS) Technologies.
Overview:
One of the remaining problems in the domain of software reuse is
how to model the different reusable assets (e.g., features,
subsystems, components, aspects) and how to describe and reason
about systems composed out of such reusable assets. Many notations
exist to model software requirements and designs, but unfortunately
they do not provide any notion for the composition of several
assets. This means, there is no support when combining several
assets to form a larger asset. Especially, there is no modelling
support given by currently used notations (like UML) to check the
reusability and consistency of assets and to check the consistency
of different views (e.g., dynamic models like state-charts and
message sequence charts). That makes it hard to reuse existing
parts, to build families of systems, and to split up requirements
or design work between several people.
In this workshop we are looking for modelling approaches enabling
the development of reusable subsystems with reasonable effort by
abstracting from details. This model-based approach to reuse should
not only allow the modeling of the required features of the system
to be built but they should also be able to describe the system as
an assembly (or configuration) of different decomposed assets. To
make reuse of the existing assets in new contexts meaningful models
of assets have to be found allowing (a) to define the desired
interactions between the different assets, (b) to detect
undesirable negative interferences of assets and (c), ultimately,
the possibility to predict properties of the overall system out of
the assets' properties. This would allow to check the properties of
the assembled (or configured) system against the requirements. Even
if not able to prove that the system is fully compliant to the
requirements, a model-based approach in reuse supports the
detection of inconsistencies and interoperability problems in early
stages of software development.
Since the issue of software composition has been raised in many
different reuse-communities, such as component-based software
engineering, software architecture, aspect-oriented programming,
etc., we would like to present and discuss in this workshop common
approaches of model-based reuse and the application and benefits of
these approaches as well as the challenges.
Topics of interest include but are not limited to:
* Models defining the assets to be reused.
* Models describing requirements, models of the architecture of
composed systems.
* Determining and modeling features on the requirements level.
* Composition and interaction problems in research and industry.
* Artificial intelligence supporting the developer with
composition and interaction problems.
* Theoretical foundation of modeling and asset inconsistency
detection and specification.
* Methods to assure certain qualities of service after composition.
* Modelling of assets and their desired relationships.
* Detection of undesired negative asset interaction.
* Conformance between model and implementation / reality and
corresponding consequences for reasoning about the
implementation / reality.
http://www.di.unipi.it/~brogi/fmci.html
Component-based software engineering (CBSE), is an emerging development
paradigm that promises to accelerate software development and to reduce
costs by assembling systems from prefabricated software components.
Designing, developing and maintaining components for reuse is, however,
a very complex process, which places high requirements not only for
component functionality and flexibility, but also for the development
organization. CBSE covers many software engineering disciplines and
different techniques which still have not been fully defined, explained
and exploited either from theoretical or practical points of view.
The aim of the conference track is to bring together practitioners and
researchers from academia and industry to improve the theories,
technologies, and processes in component-based software development. We
encourage submissions of both theoretical nature and experience
reports from academia and especially from industry. Suggested areas of
interest include, but are not restricted to:
Building systems from components Component-based embedded systems
Component Specification COTS (Commercial off theshelf)
Component Evaluation Case Studies
Component-based Architecture Component-based Software Metrics
Component compositions CBSE Organizational Issues
Software Product-line Approach
Component-based Requirements Engineering
Component Design, Implementation, Testing
CBSE and Aspect-oriented programming
Component Development Processes Component Models and Technologies
Components and Reuse Development Environment and Tools
Component Configuration Management Components for Real-time systems
Building systems from components Component-based embedded systems
Component Specification COTS (Commercial off theshelf)
Component Evaluation Case Studies
Component-based Architecture Component-based Software Metrics
Component compositions CBSE Organizational Issues
Software Product-line Approach
Component-based Requirements Engineering
Component Design, Implementation, Testing
CBSE and Aspect-oriented programming
Component-based software engineering (CBSE), is an emerging development
paradigm that promises to accelerate software development and to reduce
costs by assembling systems from prefabricated software components.
Designing, developing and maintaining components for reuse is, however,
a very complex process, which places high requirements not only for
component functionality and flexibility, but also for the development
organization. CBSE covers many software engineering disciplines and
different techniques which still have not been fully defined, explained
and exploited either from theoretical or practical points of view.
The aim of the conference track is to bring together practitioners and
researchers from academia and industry to improve the theories,
technologies, and processes in component-based software development. We
encourage submissions of both theoretical nature and experience
reports from academia and especially from industry. Suggested areas of
interest include, but are not restricted to:
Component Development Processes Component Models and Technologies
Components and Reuse Development Environment and Tools
Component Configuration Management Components for Real-time systems
Building systems from components Component-based embedded systems
Component Specification COTS (Commercial off theshelf)
Component Evaluation Case Studies
Component-based Architecture Component-based Software Metrics
Component compositions CBSE Organizational Issues
Software Product-line Approach
Component-based Requirements Engineering
Component Design, Implementation, Testing
CBSE and Aspect-oriented programming
Component-based software engineering (CBSE), is an emerging development
paradigm that promises to accelerate software development and to reduce
costs by assembling systems from prefabricated software components.
Designing, developing and maintaining components for reuse is, however,
a very complex process, which places high requirements not only for
component functionality and flexibility, but also for the development
organization. CBSE covers many software engineering disciplines and
different techniques which still have not been fully defined, explained
and exploited either from theoretical or practical points of view.
The aim of the conference track is to bring together practitioners and
researchers from academia and industry to improve the theories,
technologies, and processes in component-based software development. We
encourage submissions of both theoretical nature and experience
reports from academia and especially from industry. Suggested areas of
interest include, but are not restricted to:
Component Development Processes Component Models and Technologies
Components and Reuse Development Environment and Tools
Component Configuration Management Components for Real-time systems
Building systems from components Component-based embedded systems
Component Specification COTS (Commercial off theshelf)
Component Evaluation Case Studies
Component-based Architecture Component-based Software Metrics
Component compositions CBSE Organizational Issues
Software Product-line Approach
Component-based Requirements Engineering
Component Design, Implementation, Testing
CBSE and Aspect-oriented programming
Component-Oriented Platforms
Aims and scope
--------------
While available component-oriented platforms address software
interoperability at the signature level, the way to describe and
reason on the (concurrent) interactive behaviours of components is
still an open research issue. The scope of the workshop is the
application of formal methods to develop well-founded methodologies
for validating and certifying software compositions. The aim of the
workshop is to provide a forum for discussing the application of
formal methods to different aspects of component interaction such as
compatibility, replaceability or adaptation. Contributions on
different aspects of component interaction, such as specification,
analysis, verification, design, and implementation are welcome.
Component-based software engineering (CBSE), is an emerging development
paradigm that promises to accelerate software development and to reduce
costs by assembling systems from prefabricated software components.
Designing, developing and maintaining components for reuse is, however,
a very complex process, which places high requirements not only for
component functionality and flexibility, but also for the development
organization. CBSE covers many software engineering disciplines and
different techniques which still have not been fully defined, explained
and exploited either from theoretical or practical points of view.
The aim of the conference track is to bring together practitioners and
researchers from academia and industry to improve the theories,
technologies, and processes in component-based software development. We
encourage submissions of both theoretical nature and experience
reports from academia and especially from industry. Suggested areas of
interest include, but are not restricted to:
Component Development Processes Component Models and Technologies
Components and Reuse Development Environment and Tools
Component Configuration Management Components for Real-time systems
Building systems from components Component-based embedded systems
Component Specification COTS (Commercial off theshelf)
Component Evaluation Case Studies
Component-based Architecture Component-based Software Metrics
Component compositions CBSE Organizational Issues
Software Product-line Approach
Component-based Requirements Engineering
Component Design, Implementation, Testing
CBSE and Aspect-oriented programming
Reqts Engineering
TOPICS OF INTEREST INCLUDE, BUT ARE NOT LIMITED TO:
- solutions to known RE problems as applied to security and privacy
- RE for confidentiality, integrity, and availability
- industrial problem statements
- generalizations from individual industrial experiences
- RE for trusted Commercial Off-The-Shelf (COTS) systems
- empirical studies of industrial RE practice
- capture and expression of informal and ad hoc requirements
- managing conflicting requirements of operational effectiveness and security
- methods for the specification and analysis of security requirements
- methods for ensuring compliance between requirements and policies
Component Oriented Programming
WCOP 2002 seeks position papers on the important field of component-oriented
programming (COP). WCOP 2002 is the seventh event in a series of highly
successful workshops, which took place in conjunction with every ECOOP since
1996.
COP has been described as the natural extension of object-oriented programming
to the realm of independently extensible systems. Several important approaches
have emerged over the recent years, including component technology standards,
such as CORBA/CCM, COM/COM+, JavaBeans/EJB, and most recently .NET, but also the
increasing appreciation of software architecture for component-based systems,
and the consequent effects on organizational processes and structures as well as
the software development business as a whole.
After WCOP'96 focused on the fundamental terminology of COP, the subsequent
workshops expanded into the many related facets of component software. WCOP 2002
has an explicit focus on dynamic reconfiguration of component systems, that is,
the overlap between COP and dynamic architectures. Also, submissions reporting
on experience with component-oriented software systems in practice are strongly
encouraged, where the emphasis is on interesting lessons learned, whether the
actual project was a success or a failure.
COP aims at producing software components for a component market and for late
composition. Composers are third parties, possibly the end users, who are not
able or willing to change components. This requires standards to allow
independently created components to interoperate, and specifications that put
the composer into the position to decide what can be composed under which
conditions. On these grounds, WCOP'96 led to the following definition:
A component is a unit of composition with contractually specified
interfaces and explicit context dependencies only. Components can be
deployed independently and are subject to composition by third parties.
Often discussed in the context of COP are quality attributes (a.k.a. system
qualities). A key problem that results from the dual nature of components
between technology and markets are the non-technical aspects of components,
including marketing, distribution, selection, licensing, and so on. While it is
already hard to establish functional properties under free composition of
components, non-functional and non-technical aspects tend to emerge from
composition and are thus even harder to control. In the context of specific
architectures, what can be said about the quality attributes of systems composed
according to the architecture's constraints?
TOPICS
Topics of interest to WCOP 2002 include, but are not limited to:
* components in distributed embedded systems, including mobile phones and
PDAs
* relating architectural principles/approaches to component software
* addressing variability requirements in component-based solutions
* system design for independent extensibility
* system design for the use of third-party components
* system design for hot-swappable components
* interoperation among component frameworks
* quality attributes
* component-aware processes
* declarative forms of composition/configuration
* deployment attribution / constraints
* component versus application evolution
* domain-specific (vertical) standards
* dynamic architectures
* architecture description languages suitable to guide COP
* performance/efficiency of component-based systems
* organizational aspects
* business aspects
* what worked / what didn't work in practice and lessons learned
Reliability and Security
As we move past the first wave of the internet and e-commerce based
systems and applications, the concerns about the reliability and
security of these business/mission critical systems are beginning to
surface. Being held in the Washington DC area in close proximity to
the US government agencies, it is only appropriate that we pick
reliability and security of business/mission critical systems as our
theme for ISSRE 2002. We hope to bring a good mixture of theory and
practices to highlight the problems and potential solutions in this
vital area of the information technology. Topics of interest include
(but are not limited to):
- Network system reliability
- Internet reliability engineering
- Quality of network service
- Electronic commerce
- Practice of reliability modeling
- Reliability measurement
- Software testing and verification
- Software reliability models
- Fault-tolerant and robust software
- Software architecture reliability
- Analysis and prevention of virus attacks
- Secure software engineering
- Security testing and certification
- Reliability of distributed systems
- Standards and regulation
- Dependable web-services
Web Services and Service-Oriented Architectures
IC'2002 Section on Web Services and Service-Oriented Architectures
The 2002 International Conference on Internet Computing (IC'2002)
June 24-27, 2002, Las Vegas, NV, USA
http://fontoura.org/ic2002.html
Call for papers:
Service-oriented architectures (SOA) are a new paradigm for software
development in which agents may dynamically discover and use Internet
services. Internet services are nothing more than components that can be
accessed through the Internet to deliver particular tasks. Examples of
Internet services include online shopping carts, weather information, stock
quotes, and printing.
SOA enhance the traditional software development process, since programmers
can built applications based on Internet services, even if these services
are not yet available or not they are not known by developers. The idea is
that services are described through a service description language,
dynamically discovered by applications that need to use them, and invoked
through the communication protocol defined in its interface.
This flexible architecture has already shown its usefulness. One example is
the automation of the B2B buying process, where buyers can dynamically
discover sellers and perform the buying process without human interaction.
However, there are still many issues that should be addressed in the design
and implementation of service-based applications, including:
- Middleware support for SOA and Web services;
- Extensions and limitations of application protocols (SOAP, WSDL, UDDI);
- Security & trust;
- Service performance and availability;
- Applications of SOA and Web services.
Research papers and industrial reports on the above issues (or on any issue
related to SOA and Web services) are welcome. The review process will be
based on the quality of the submitted papers and their relevance to the
area.
Papers should have up to 7 single sided pages with font size of 10 to 12,
including figures and references. Papers should be submitted by e-mail to
the organizer in MS-WORD, or PDF. The first page of the draft paper should
include: title of the paper, name, affiliation, postal address, e-mail
address, telephone number, and fax number for each author. Accepted papers
will be part of the conference proceedings. The length of the Camera-Ready
papers (if accepted) will be limited to 7 (IEEE style) pages. Papers must
not have been previously published or currently submitted for publication
elsewhere.
Generators and Components
Program generation has the prospect of being an integral part of a
wide range of software development processes. Many recent studies
investigate different aspects of program generation, including their
semantics, their application, and their implementation. Existing
theories and systems address both high-level (source) language and
low-level (machine) language generation. A number of programming
languages now support program generation and manipulation, with
different goals, implementation techniques, and targeted at different
applications. The goal of this conference is to provide a meeting
place for researchers and practitioners interested in this topic.
A particular area of interest is component-based software development,
which bears the promise of considerable productivity increases to
software development comparable to the introduction of the assembly
line in manufacturing. But due to the very same sophistication that
makes components useful, their maintenance can be hard. Generative
programming presents a promising approach to alleviating the above
problems, as changes affecting components can now be more effectively
managed during the generation process rather than at the component
level.
* Generative Programming: Reuse, meta-programming, partial evaluation,
multi-stage and multi-level languages,
* Semantics, type systems, symbolic computation, linking and explicit
substitution, in-lining and macros, templates, program transformation,
* Runtime code generation, compilation, active libraries, synthesis from
specifications, development methods, generation of non-code artifacts,
formal methods. Reflection.
* Component-Based Software Engineering: Reuse, distributed platforms,
distributed systems, evolution, analysis and design patterns,
development methods, formal methods
* Integration of Generative and Component-Based Approaches
* Domain Engineering, analysis, and languages
* Separation of Concerns: Aspect-Oriented Programming, Intentional
* Programming, and Multi-Dimensional Separation of Concerns
* Product Lines and generic architectures for that purpose.
* Industrial Applications of Components and Generative Programming
The goal of this workshop is to examine the process of component-based
software development in all phases of the development life-cycle (i.e.,
specification, design, composition, testing, deployment) and to identify
how this process needs to be different from traditional software
development. Participation is encouraged both from practitioners to
provide their experiences and help in identifying open questions, and
from researches to suggest methodological support for addressing these
questions. The ultimate goals is thus to enable an exchange of
experience between practitioners and researches concerning the relevance
and feasibility of using the component paradigm throughout the software
life-cycle.
Participation
---------------
Participants are asked to write a position paper (3000-5000 words) on
appropriate concepts, methods and applications. A non-exhaustive list of
topics includes:
- Methodological foundation of component-based software development;
- Modeling of component-based systems (UML and others);
- Tools supporting component-based development;
- Integration of the component paradigm into existing environments;
- Component testing, verification, distribution, maintenance;
- Combination of heterogeneous component technologies;
- Extension of ‚standard’ technologies to support component-based
development
(e.g., databases, languages, compiler, XML etc.);
- Industrial experience reports.
WWW
The WWW is now a familiar channel for information dissemination and gathering among people from all walks of life. The sheer variety and amount of information that may be obtained are staggering. Academics and researchers now have another avenue to publish their research and satisfy their quest for knowledge. Many are discovering and tapping vast amounts of information never dreamed of before. Team workers utilise the Web for remote collaboration. Corporations with business sense have established a Web presence by reconstituting corporate materials and product information for Web publication. The consumer has benefited from access to large amounts of dynamic data; this has also enabled comparison-shopping and assisted decision-making.
Hence, the Web has become somewhat indispensable to many and for various reasons. The aim of this conference is to provide an international forum for researchers, professionals, and industrial practitioners to share their knowledge in the rapidly growing area of Web technologies.
We invite submissions that address both fundamental issues of Web data management and issues related to the development and management of Web-based applications. Suggested topics include, but are not limited to:
* Deep/Hidden Web * Web Ontologies
* Mobile Web Information Systems * Web Performance
* Semantic Web * Web Query Languages
* Web Agents * Web Security
* Web Change Monitoring & Management * Web Services
* Web Commerce * Web Tools & Languages
* Web Data Model * Web Transactions
* Web Information Retrieval * Web Visualization
* Web Intelligence * Web Warehousing
* Web Metrics * Web-Based Business Processes
* Web Mining * XML & Semi-structured data
Extreme Programming
|
|
| What is Extreme
Programming? 11/08/2001 |
In Extreme Programming, every contributor to the project is an integral part of the "Whole Team". The team forms around a business representative called "the Customer", who sits with the team and works with them daily.
Extreme Programming teams use a simple form of planning and tracking to decide what should be done next and to predict when the project will be done. Focused on business value, the team produces the software in a series of small fully-integrated releases that pass all the tests the Customer has defined.
Extreme Programmers work together in pairs and as a group, with simple design and obsessively tested code, improving the design continually to keep it always just right for the current needs.
The Extreme Programming team keeps the system integrated and running all the time. The programmers write all production code in pairs, and all work together all the time. They code in a consistent style so that everyone can understand and improve all the code as needed.
The Extreme Programming team shares a common and simple picture of what the system looks like. Everyone works at a pace that can be sustained indefinitely.
All the contributors to an XP project sit together, members of one team. This team must include a business representative -- the "Customer" -- who provides the requirements, sets the priorities, and steers the project. It's best if the Customer or one of her aides is a real end user who knows the domain and what is needed. The team will of course have programmers. The team may include testers, who help the Customer define the customer acceptance tests. Analysts may serve as helpers to the Customer, helping to define the requirements. There is commonly a coach, who helps the team keep on track, and facilitates the process. There may be a manager, providing resources, handling external communication, coordinating activities. None of these roles is necessarily the exclusive property of just one individual: Everyone on an XP team contributes in any way that they can. The best teams have no specialists, only general contributors with special skills.
XP planning addresses two key questions in software development: predicting what will be accomplished by the due date, and determining what to do next. The emphasis is on steering the project -- which is quite straightforward -- rather than on exact prediction of what will be needed and how long it will take -- which is quite difficult. There are two key planning steps in XP, addressing these two questions:
Release Planning is a practice where the Customer presents the desired features to the programmers, and the programmers estimate their difficulty. With the costs estimates in hand, and with knowledge of the importance of the features, the Customer lays out a plan for the project. Initial release plans are necessarily imprecise: neither the priorities nor the estimates are truly solid, and until the team begins to work, we won't know just how fast they will go. Even the first release plan is accurate enough for decision making, however, and XP teams revise the release plan regularly.
Iteration Planning is the practice whereby the team is given direction every couple of weeks. XP teams build software in two-week "iterations", delivering running useful software at the end of each iteration. During Iteration Planning, the Customer presents the features desired for the next two weeks. The programmers break them down into tasks, and estimate their cost (at a finer level of detail than in Release Planning). Based on the amount of work accomplished in the previous iteration, the team signs up for what will be undertaken in the current iteration.
These planning steps are very simple, yet they provide very good information and excellent steering control in the hands of the Customer. Every couple of weeks, the amount of progress is entirely visible. There is no "ninety percent done" in XP: a feature story was completed, or it was not. This focus on visibility results in a nice little paradox: on the one hand, with so much visibility, the Customer is in a position to cancel the project if progress is not sufficient. On the other hand, progress is so visible, and the ability to decide what will be done next is so complete, that XP projects tend to deliver more of what is needed, with less pressure and stress.
As part of presenting each desired feature, the XP Customer defines one or more automated acceptance tests to show that the feature is working. The team builds these tests and uses them to prove to themselves, and to the customer, that the feature is implemented correctly. Automation is important because in the press of time, manual tests are skipped. That's like turning off your lights when the night gets darkest.
The best XP teams treat their customer tests the same way they do programmer tests: once the test runs, the team keeps it running correctly thereafter. This means that the system only improves, always notching forward, never backsliding.
XP teams practice small releases in two important ways:
First, the team releases running, tested software, delivering business value chosen by the Customer, every iteration. The Customer can use this software for any purpose, whether evaluation or even release to end users (highly recommended). The most important aspect is that the software is visible, and given to the customer, at the end of every iteration. This keeps everything open and tangible.
Second, XP teams release to their end users frequently as well. XP Web projects release as often as daily, in house projects monthly or more frequently. Even shrink-wrapped products are shipped as often as quarterly.
It may seem impossible to create good versions this often, but XP teams all over are doing it all the time. See Continuous Integration for more on this, and note that these frequent releases are kept reliable by XP's obsession with testing, as described here in Customer Tests and Test-Driven Development.
XP teams build software to a simple design. They start simple, and through programmer testing and design improvement, they keep it that way. An XP team keeps the design exactly suited for the current functionality of the system. There is no wasted motion, and the software is always ready for what's next.
Design in XP is not a one-time thing, or an up-front thing, it is an all-the-time thing. There are design steps in release planning and iteration planning, plus teams engage in quick design sessions and design revisions through refactoring, through the course of the entire project. In an incremental, iterative process like Extreme Programming, good design is essential. That's why there is so much focus on design throughout the course of the entire development.
All production software in XP is built by two programmers, sitting side by side, at the same machine. This practice ensures that all production code is reviewed by at least one other programmer, and results in better design, better testing, and better code.
It may seem inefficient to have two programmers doing "one programmer's job", but the reverse is true. Research into pair programming shows that pairing produces better code in about the same time as programmers working singly. That's right: two heads really are better than one!
Some programmers object to pair programming without ever trying it. It does take some practice to do well, and you need to do it well for a few weeks to see the results. Ninety percent of programmers who learn pair programming prefer it, so we highly recommend it to all teams.
Pairing, in addition to providing better code and tests, also serves to communicate knowledge throughout the team. As pairs switch, everyone gets the benefits of everyone's specialized knowledge. Programmers learn, their skills improve, they become move valuable to the team and to the company. Pairing, even on its own outside of XP, is a big win for everyone.
Extreme Programming is obsessed with feedback, and in software development, good feedback requires good testing. Top XP teams practice "test-driven development", working in very short cycles of adding a test, then making it work. Almost effortlessly, teams produce code with nearly 100 percent test coverage, which is a great step forward in most shops. (If your programmers are already doing even more sophisticated testing, more power to you. Keep it up, it can only help!)
It isn't enough to write tests: you have to run them. Here, too, Extreme Programming is extreme. These "programmer tests", or "unit tests" are all collected together, and every time any programmer releases any code to the repository (and pairs typically release twice a day or more), every single one of the programmer tests must run correctly. One hundred percent, all the time! This means that programmers get immediate feedback on how they're doing. Additionally, these tests provide invaluable support as the software design is improved.
Extreme Programming focuses on delivering business value in every iteration. To accomplish this over the course of the whole project, the software must be well-designed. The alternative would be to slow down and ultimately get stuck. So XP uses a process of continuous design improvement called Refactoring, from the title of Martin Fowler's book, "Refactoring: Improving the Design of Existing Code".
The refactoring process focuses on removal of duplication (a sure sign of poor design), and on increasing the "cohesion" of the code, while lowering the "coupling". High cohesion and low coupling have been recognized as the hallmarks of well-designed code for at least thirty years. The result is that XP teams start with a good, simple design, and always have a good, simple design for the software. This lets them sustain their development speed, and in fact generally increase speed as the project goes forward.
Refactoring is, of course, strongly supported by comprehensive testing to be sure that as the design evolves, nothing is broken. Thus the customer tests and programmer tests are a critical enabling factor. The XP practices support each other: they are stronger together than separately.
Extreme Programming teams keep the system fully integrated at all times. We say that daily builds are for wimps: XP teams build multiple times per day. (One XP team of forty people builds at least eight or ten times per day!)
The benefit of this practice can be seen by thinking back on projects you may have heard about (or even been a part of) where the build process was weekly or less frequently, and usually led to "integration hell", where everything broke and no one knew why.
Infrequent integration leads to serious problems on a software project. First of all, although integration is critical to shipping good working code, the team is not practiced at it, and often it is delegated to people who are not familiar with the whole system. Second, infrequently integrated code is often -- I would say usually -- buggy code. Problems creep in at integration time that are not detected by any of the testing that takes place on an unintegrated system. Third, weak integration process leads to long code freezes. Code freezes mean that you have long time periods when the programmers could be working on important shippable features, but that those features must be held back. This weakens your position in the market, or with your end users.
On an Extreme Programming project, any pair of programmers can improve any code at any time. This means that all code gets the benefit of many people's attention, which increases code quality and reduces defects. There is another important benefit as well: when code is owned by individuals, required features are often put in the wrong place, as one programmer discovers that he needs a feature somewhere in code that he does not own. The owner is too busy to do it, so the programmer puts the feature in his own code, where it does not belong. This leads to ugly, hard-to-maintain code, full of duplication and with low (bad) cohesion.
Collective ownership could be a problem if people worked blindly on code they did not understand. XP avoids these problems through two key techniques: the programmer tests catch mistakes, and pair programming means that the best way to work on unfamiliar code is to pair with the expert. In addition to ensuring good modifications when needed, this practice spreads knowledge throughout the team.
XP teams follow a common coding standard, so that all the code in the system looks as if it was written by a single -- very competent -- individual. The specifics of the standard are not important: what is important is that all the code looks familiar, in support of collective ownership.
Extreme Programming teams develop a common vision of how the program works, which we call the "metaphor". At its best, the metaphor is a simple evocative description of how the program works, such as "this program works like a hive of bees, going out for pollen and bringing it back to the hive" as a description for an agent-based information retrieval system.
Sometimes a sufficiently poetic metaphor does not arise. In any case, with or without vivid imagery, XP teams use a common system of names to be sure that everyone understands how the system works and where to look to find the functionality you're looking for, or to find the right place to put the functionality you're about to add.
Extreme Programming teams are in it for the long term. They work hard, and at a pace that can be sustained indefinitely. This means that they work overtime when it is effective, and that they normally work in such a way as to maximize productivity week in and week out. It's pretty well understood these days that death march projects are neither productive nor produce quality software. XP teams are in it to win, not to die.
Extreme Programming is a discipline of software development based on values of simplicity, communication, feedback, and courage. It works by bringing the whole team together in the presence of simple practices, with enough feedback to enable the team to see where they are and to tune the practices to their unique situation.
A subsequent article will discuss the common questions and variations within XP. If you have concerns, please write and we'll try to include them in the followup article.
Here's a picture showing the practices and the main "cycles" of XP.
The original XProgramming page on this topic is still available for your reference.
XProgramming > XP Magazine > What is Extreme Programming?UP_Grade On_Line
Systems are upgraded to improve their functionality, provide new
services, correct faults and accommodate changes in the system
environment. The number of application areas in which systems should
be able to deliver continuous reliable service during on-line
upgrades is growing. On-line system upgrading is nowadays quickly
becoming an issue affecting the success of many an enterprise. It
can, for example, reduce the downtime of telecommunication services,
allow for on-the-fly bug corrections of space mission software and
make it possible to dynamically change a complex Internet application
built as an integration of existing independent web services.
The complexity of modern applications is very high and on-line
upgrading should not be performed in an ad hoc fashion. Several
international organisations (including OMG and Java Community
Process) are working on proposals for specifying models and APIs
supporting on-line system upgrades. There is a need to design general
systematic and practical methods and techniques supporting
development and deployment of upgradable systems.
System dependability is a crucial property that must not be
undermined during upgrading or as a result of it. Besides, it should
be possible to use the natural redundancy of having both the upgraded
and old software to allow for a smooth transition to the old version
if necessary.
Aims and Topics
The main theme of the workshop is to develop approaches to
dependable systematic on-line system upgrading. The workshop aims at
- bringing together practitioners, researchers and system developers
working on the issues related to on-line upgrading of distributed
systems
- developing a better understanding of the problems that developers
face while dealing with on-line system upgrading
- defining a research agenda for developing distributed upgradable systems.
We are interested in submissions from both industry and academia on
all topics related to on-line upgrading of distributed systems. These
include, but are not limited to:
- software architectures for upgradable systems
- tools and platforms supporting dependable on-line upgrading
- error detection and recovery during system upgrading
- software engineering issues of developing systems that are easy to
modify on-line
- structuring techniques to make systems upgradable and on-line
upgrading reliable
- formal approaches to reasoning about properties of systems during
and after their upgrading
- exception handling techniques for system upgrade
- fault tolerant techniques guaranteeing consistency of upgrading
- approaches addressing issues of interoperability/compatibility of
different versions
- employing redundancy and diversity during and after system upgrading
- issues of on-line upgrading of complex systems built of components
and legacy code
- techniques to support on-line dealing with interface changes
- dynamic upgrading of database systems
Web Applications
In the near future, an increasing number of Web applications will become
"ubiquitous" i.e., delivered to a variety of devices and communication channels,
and will often be targeted to inexpert users. Their quality - in terms of
customised behaviour and effectiveness of their development/maintainance
lifecycle - may be threatened by the current inability to properly design them.
The UWA project aims at defining a set of methodologies, notations, and tools
to tackle the main for-seen problems in the design of such applications. These
include the definition of proper concepts and languages for describing their
behaviour, the ability of tracking correlations among their different components,
and the capability of correlating their requirements to design and
implementation. In order to address the need for standards in design and
documents notation, the project defined suitable extensions to the Unified
Modeling Language (UML).
The workshop hosts presentations and tutorials about requirements elicitation,
design, and customisation of ubiquitous Web applications. The presentations are
targeted at technology and product managers, designers and developers, from
both academia and industry. The workshop is also supported by leading
personalities from the industrial and research communities, who will be
presenting the state of art in the fields of context awareness (Tom Gross,
Frauenhofer Institute, Germany), e-Services (Fabio Casati, Hewlett-Packard
Labs, Palo Alto, USA), and the future of the Web (Roy Fielding, Chairman of
the Apache Software Foundation, USA).
Key topics addressed by this workshop are:
* Design of Web-based applications
* Context awareness
* Design methods
* Ubiquity and multi-channel delivery
* Requirements for ubiquitous Web-based applications
* Customisation
* e-Services
WEB Issues
The WWW is now a familiar channel for information dissemination and gathering among people from all walks of life. The sheer variety and amount of information that may be obtained are staggering. Academics and researchers now have another avenue to publish their research and satisfy their quest for knowledge. Many are discovering and tapping vast amounts of information never dreamed of before. Team workers utilize the Web for remote collaboration. Corporations with business sense have established a Web presence by reconstituting corporate materials and product information for Web publication. The consumer has benefited from access to large amounts of dynamic data; this has also enabled comparison-shopping and assisted decision-making.
Hence, the Web has become somewhat indispensable to many and for various reasons. The aim of this conference is to provide an international forum for researchers, professionals, and industrial practitioners to share their knowledge in the rapidly growing area of Web technologies.
We invite submissions that address both fundamental issues of Web data management and issues related to the development and management of Web-based applications. Suggested topics include, but are not limited to:
* Deep/Hidden Web * Web Ontologies
* Mobile Web Information Systems * Web Performance
* Semantic Web * Web Query Languages
* Web Agents * Web Security
* Web Change Monitoring & Management * Web Services
* Web Commerce * Web Tools & Languages
* Web Data Model * Web Transactions
* Web Information Retrieval * Web Visualization
* Web Intelligence * Web Warehousing
* Web Metrics * Web-Based Business Processes
* Web Mining * XML & Semi-structured data
Refinement
Refinement is one of the cornerstones of a formal approach to software
engineering.
Refinement is the process of developing a more detailed design or
implementation from an abstract specification through a sequence of
mathematically-based steps that maintain correctness with respect to the
original specification.
The aim of this BCS FACS Refinement Workshop is to bring together people who
are interested in the development of more concrete designs or executable
programs from abstract specifications using formal notations, tool support for
formal software development, and practical experience with formal refinement
methodologies.
The purpose of the workshop is to provide a forum for the exchange of ideas,
and discussion of common ground and key differences.
Topics of interest include (but are not limited to):
Simulation techniques
Foundations and semantics
Case studies (specification and verification)
Compositional and modular reasoning
Object-orientation
Time
Specification notations
Programming models
Verification and tool support
E-Systems Development
E-Systems Development: Architectures, Models, Methods, and Methodologies
CFP website:
http://bajaj.heinz.cmu.edu/AMCIS_2002/
Many of the new system development projects are related to E-Commerce and
M-Commerce systems - or E-Systems for short. Despite their potential impact
on commerce, E-Systems development is still in its infancy stage and more
research is warranted in the area. The aim of this minitrack is to provide
a forum for addressing architectures, models, methods and methodologies
that can be used for all types of E-Systems (B2B, B2C, C2C, E2C, E2B, etc.).
This minitrack proposal is a continuation of the minitrack at AMCIS'99
(Web-based Systems Development), AMCIS'00 (E-Commerce Systems: Architecture,
Infrastructure, Model, and Development Methodology), and AMCIS'01
(E-Commerce/M-Commerce Systems: Architecture, Models and Development
Methodologies, all of which
enjoyed a large amount of interest.
In an effort to bridge academic research and industry practice, we
welcome both research articles and experience reports. We look for strong
technical research papers (e.g., proposing an architecture or infrastructure,
proposing or enhancing a method or methodology for e-systems development,
describing a new security technique) and good practitioner-oriented papers
(e.g., reporting a case study). The minitrack is receptive to all types
of empirical research methodologies (e.g., case study, action research,
experimentation, survey, simulation).
Submissions should have the following components (unless a component
is not relevant to a research):
Comprehensive literature review
Sound theoretical foundation
Clearly defined research question(s) and/or hypotheses
Valid research methodology/framework/model
Good discussion of research results or potential results
We are interested in the following topics (not exhaustive):
Web database
Web engineering
Method engineering
Component engineering
Data interchange standards
Architecture for E-Systems (e.g., CORBA, DCOM)
Security issues related to E-Systems
Economic/Costing model for E-Systems
Virtual archive and data retrieval for E-Systems
E-Systems development methods and methodologies (e.g., UML, UP)
Supply Chain Integration/Management for E-Systems
Project management tools for E-Systems development
Extreme Programming/Extreme Modeling for e-systems
Cognitive, human factor, and user-interface issues in E-Systems
CASE tools and software for developing applications in E-Systems
Evaluation of analysis and design methods and methodologies for E-Systems
OO Systems
The primary goal of learning and teaching object-oriented concepts is
to enable people to successfully participate in an object-oriented
development project.
Successfully using object-oriented technology requires a thorough
understanding of basic OO concepts. However, learning these
techniques, as well as lecturing about these concepts has proven to
be very difficult in the past. Misconceptions can occur during the
learning cycle and the needed guidance can not always be directly
provided.
The goal of this workshop is to share ideas about innovative teaching
approaches and tools to improve the teaching and learning of the
basic concepts of object technology rather than teaching a specific
programming language. Teaching tools can be either tools used in
environments or specific environments for learning OO, as well as any
kind of support for developing OO learning applications themselves.
This is the sixth in a series of workshops on issues in
object-oriented teaching and learning. Previous workshops were held
at OOPSLA'97, ECOOP'98, OOPSLA'99, ECOOP'00 and OOPSLA '01 and
focused on project courses, classroom examples and metaphors, and
tools and environments.
Suggested Topics
------------
This workshop will focus on any kind of (computer-aided) support for
teaching about the basic concepts of object technology. Suggested
topics include, but are not limited to
* approaches and tools for teaching design early
* intelligent environments for learning and teaching
* frameworks/toolkits/libraries for learning support
* microworlds
* different pedagogies
* top-down vs. bottom-up approaches
* design early vs. design late
* topic presentation issues
* frameworks/toolkits for the development of teaching/learning
applications
* non-trivial examples to exemplify OO concepts
Types
Modern programming languages rely on type systems with static type
checking to detect common errors at compile time. While the benefits
of statically checked type systems have long been recognized, there
are some areas where the type systems of modern programming languages
are not expressive enough. Some interesting programs will always be
rejected, despite their semantical soundness.
There are several remedies to this situation, ranging from dependent
types (where types may contain values) through intersection types to
types with modalities. These systems are well-investigated from a
theoretical point of view by logicians and type theorists. However,
the impact of these developments on practical programming has been
small, partly because they are trading simplicity against
expressivity.
The objective of the workshop is to make researchers in programming
languages aware of new developments and research directions on the
theory side while at the same time pointing out problems arising in
practical uses to theorists. Technical topics include, but are not
limited to:
* Type systems in all variants: polymorphic, dependent, intersection,
modal, linear.
* Annotated type systems.
* Low-level type systems.
* Advanced uses and applications.
Requirements Engineering
All along the software lifecycle, managers and programs
use models to guide system development. Such models can be used to:
** Document the dialogues seen to date,
** Structure future dialogues; e.g. when clarifying certain details
of a model.
We call all such models "requirements" since they all comment on
required system behavior; i.e. what is expected, what is missing,
what is wrong, and what should be added to the current system. Note
that such "requirements" can appear at the beginning of the
lifecycle AND at other times (e.g. test engineers often reverse
engineer a requirements model prior to assessing code).
Sophisticated methods exist for reasoning about models; e.g. formal
refinement theory and model checking. These methods often make some
"completeness assumption"; e.g.
** The model contains all the information relevant to an application
** The model contains no contradictions.
Such complete models are rare in SE since data collection is
expensive, and competing stakeholders rarely agree. This special issue
aims at collectings state-of-the-art papers relating to the pragmatic
reasoning over incomplete systems models. Contributions may include
case studies or research papers or tutorial overviews of the field of
MBRE.
General topics relevant to MBRE include (and are not restricted to)
discussion of how to:
** Structure these incomplete models.
** Build, validate, and maintain these incomplete models.
** Adapt these incomplete so they are relevant to the current project.
** Apply incomplete models to a current project.
** Take an incomplete model and prepare it for future reuse.
** Do the above, in a cost effective manner
Specific topics relevant to MBRE include (and are not restricted to):
** bayesian reasoning
** conflict detection and resolution
** contradiction-tolerant reasoning systems (e.g. abduction)
** exploring models that contain unknowns and contradictions using:
-- theorem provers
-- model checkers
** formal models of best practice
** fuzzy logic
** incremental knowledge acquisition and maintenance tools
** integrated project management tools
** learning algorithms to create or explore incomplete models including:
-- nueral nets,
-- genetic algorithms
-- associational rule learners
-- inductive logic programming
-- decision tree learners
** model-based reasoning tools
** model-resue stragies (e.g. using COTS software)
** model checking
** model refinement methods
** model validation methods (e.g. statistical, other)
** multi-criteria decision making
** risk balancing
** simulation and summarization techniques
** stakeholder-based reasoning
** useful schemas for constructing models
** validation of models of best practice
** visualization tools
For more on MBRE, see the on-line proceedings of the First
International Workshop on Model-based Requirements Engineering at
http://www.bfsng.com/mbre01/agenda.htm.
Knowledge-Based OO Software Engineering
The complexity of software domains - such as the financial industry,
television and radio broadcasting, hospital management and rental
business - is steadily increasing and knowledge management of businesses
is becoming more important with the demand for capturing business
processes. On the other hand the volatility of software development
expertise needs to be reduced. These are symptoms of a very significant
tendency towards making knowledge of different kinds explicit: knowledge
about the domain or the business, knowledge about developing software,
even meta-knowledge about these kinds of knowledge.
Knowledge in software applications is becoming more significant because
the domains of many software applications are inherently
knowledge-intensive and this knowledge is often not explicitly dealt
with in software development. This impedes maintenance and reuse.
Moreover, it is generally known that developing software requires
expertise and experience, which are currently also implicit and could be
made more tangible and reusable using knowledge-based or related
techniques. These are general examples of how using explicit knowledge
in a multitude of ways and in all phases of software development can be
advantageous.
Since object-orientation is derived from frames in frame-based knowledge
representation in AI, object-oriented software development in se has
certain advantages for making knowledge explicit. A conceptual class
diagram, for example, models domain knowledge. Also, object-oriented
programs can be designed in such a way that certain knowledge is
represented explicitly and more or less separated from other
implementation issues. However, knowledge might require a more
declarative representation such as constraints or rules, thus requiring
to augment object-oriented software development with these techniques.
Examples are UML's Object Constraint Language, or recent trends in using
business rules and ontologies.
The long-term goals of this workshop are to provide a platform for
researchers and practitioners interested in knowledge-based or related
approaches for object-oriented programming or software development, to
pursue and encourage research and applications in this area, and to
bridge the gap between the ECOOP community and the long-standing
community active in the conferences on Software Engineering and
Knowledge Engineering (SEKE) and Automated Software Engineering (ASE),
formerly known as Knowledge-Based Software Engineering. For the
short-term goals we would like to address among others the following:
* identify and characterise
- object-oriented engineering tasks that can benefit from explicitly
used knowledge
- (knowledge-based) approaches that can support object-oriented
engineering tasks
- kinds of knowledge that are useful to make explicit
- how explicit knowledge can be used
* look for a common life cycle which describes both the conventional
object-oriented software construction and the knowledge based software
construction
* the symbiosis between knowledge-based or related approaches and
object-oriented programming
* industrial applications of explicit knowledge in object-oriented
software
Topics of interest for this workshop include, but are by no means
limited to:
* software engineering tasks where explicit knowledge can be useful
- requirements engineering
- analysis
- design
- programme understanding
- reengineering
- reverse engineering
- software evolution
- software reuse
- ...
* approaches for making knowledge explicit
- knowledge engineering
- ontologies
- conceptual modeling
- domain analysis and domain engineering
- business rules
- workflow management
- ...
* how explicit knowledge can be used
- modeling
- enforcing
- checking and verifying
- prescriptive/descriptive/restrictive
- code generation
Formal Software Engineering - Resolve
RESOLVE Workshop 2002 will bring together educators and researchers
interested in refining formal approaches to software engineering,
especially component-based systems, and introducing them into the
classroom. This meeting will provide a forum for participants to
present and discuss recent advances, trends, and concerns in these
areas, as well as formulate a common understanding of emerging
research issues and possible solution paths. We invite you to
participate by submitting a paper to either the education or
research track of the workshop. Topics of interest include:
* Infusing software engineering techniques into computer science
education:
-- Design with reuse
-- Design for reuse
-- Modular reasoning
-- Component-based software
-- Formal specification
-- Formal verification
-- Software testing
-- Using RESOLVE in the undergraduate curriculum
-- Pedagogical techniques to help teach the above topics
-- Using RESOLVE in the graduate curriculum
* Software engineering research on formal approaches to
component-based systems:
-- Specification and verification of performance properties
-- Modular approaches to detecting component interface violations
-- Trade-offs among testing, formal verification, and model checking
-- Combining concurrency-oriented formalisms with model-based
behavioral specification approaches
-- Formal characterization of user interfaces
-- Formal modeling of file system behavior
-- Formal characterization of mathematical and program types
-- Software engineering environments and tools
-- The Java Modeling Language (JML)
-- RESOLVE language and implementation issues
KB Software Engineering
TOPICS
-Architecture of knowledge, software and information systems including
collaborative, distributed, multi-agent and multimedia systems, internet and
intranet,
-Requirements engineering, domain analysis and modeling, formal and
semiformal specifications,
-Knowledge engineering for domain modeling, system family engineering, and
software product lines,
-Intelligent user interfaces and human-machine interaction,
-Knowledge acquisition and discovery, data mining,
-Automating software design and synthesis,
-Object-oriented and other programming paradigms, metaprogramming,
-Reuse, re-engineering, reverse engineering,
-Knowledge-based methods and tools for software engineering, including
testing, verification and validation, process management, maintenance and
evolution, CASE,
-Decision support methods for software engineering,
-Applied semiotics for knowledge-based software engineering,
-Knowledge systems methodology, development tools and environments,
-Practical applications and experience of software and knowledge
engineering,
-Information technology in control, design, production, logistics and
management,
-Enterprise modeling, workflow,
-Knowledge management for business process,
-Intelligent agents for software engineering,
-Program understanding, programming knowledge, learning of programming,
modeling programs and programmers,
-Knowledge-based methods and tools for software engineering education,
-Software engineering and knowledge engineering education, distance
learning.
Program Comprehension
Software is inherently complex through the number of artifacts in any system
and their relationships. Software comprehension draws on aspects of reverse
engineering, cognitive software comprehension, CASE tools, visualization
techniques, and usability aspects and tools used within in the software
comprehension community. The focus of this session will be on current and
future challenges in the program comprehension domain.
Papers are invited on both theoretical and practical aspects of software
comprehension including topics relating to:
- Novel ideas for comprehension approaches and software visualization,
including comprehension strategies for distributed and concurrent systems
- Combining visualization with other analysis and comprehension techniques
- Usability analysis and empirical user studies
- Usability and learnability aspects in program comprehension
- Theories and models for software comprehension
- Experimental results
- Supporting tools
Software Engineering Research
Continuous System Upgrade
Systems are upgraded to improve their functionality, provide new
services, correct faults and accommodate changes in the system
environment. The number of application areas in which systems should
be able to deliver continuous reliable service during on-line
upgrades is growing. On-line system upgrading is nowadays quickly
becoming an issue affecting the success of many an enterprise. It
can, for example, reduce the downtime of telecommunication services,
allow for on-the-fly bug corrections of space mission software and
make it possible to dynamically change a complex Internet application
built as an integration of existing independent web services.
The complexity of modern applications is very high and on-line
upgrading should not be performed in an ad hoc fashion. Several
international organisations (including OMG and Java Community
Process) are working on proposals for specifying models and APIs
supporting on-line system upgrades. There is a need to design general
systematic and practical methods and techniques supporting
development and deployment of upgradable systems.
System dependability is a crucial property that must not be
undermined during upgrading or as a result of it. Besides, it should
be possible to use the natural redundancy of having both the upgraded
and old software to allow for a smooth transition to the old version
if necessary.
Aims and Topics
The main theme of the workshop is to develop approaches to
dependable systematic on-line system upgrading. The workshop aims at
- bringing together practitioners, researchers and system developers
working on the issues related to on-line upgrading of distributed
systems
- developing a better understanding of the problems that developers
face while dealing with on-line system upgrading
- defining a research agenda for developing distributed upgradable systems.
We are interested in submissions from both industry and academia on
all topics related to on-line upgrading of distributed systems. These
include, but are not limited to:
- software architectures for upgradable systems
- tools and platforms supporting dependable on-line upgrading
- error detection and recovery during system upgrading
- software engineering issues of developing systems that are easy to
modify on-line
- structuring techniques to make systems upgradable and on-line
upgrading reliable
- formal approaches to reasoning about properties of systems during
and after their upgrading
- exception handling techniques for system upgrade
- fault tolerant techniques guaranteeing consistency of upgrading
- approaches addressing issues of interoperability/compatibility of
different versions
- employing redundancy and diversity during and after system upgrading
- issues of on-line upgrading of complex systems built of components
and legacy code
- techniques to support on-line dealing with interface changes
- dynamic upgrading of database systems
Information Integration
At the core of the information revolution brought by the Web is the ability
to effectively and efficiently share and exchange information virtually with
anyone anytime anywhere. Yet, it is very hard to keep up to date with the
ever-increasing sophistication of the tools and techniques available at the
dawn of the 21st century for building the future information society.
Industrial, commercial, educational, and information society institutions
and organizations whose activities rely more and more on information
technology cannot afford to ignore the latest technological and
infra-structural development and trends of the Internet. Business to
consumer, business to business, and business to government transactions,
business intelligence, decision support at every level of the enterprise are
conducted competitively only when they tap into the information resources
offered by the world wide web and when they leverage the latest tools and
techniques available.
IIWAS2002 aims to provide a forum for the discussion and exchange of ideas
and information by researchers, students, and professionals on the issues
and challenges brought on by Internet technology for the intelligent
integration of information.
Topics of Interest
------------------
The conference solicits full-length research or position papers. The list
below is a suggested, but not necessarily exhaustive, list of topics of
interest and relevance to the conference.
1. Information Systems Integration
· Schema and Data Integration
· Data Integration and Enterprise Security
· Distributed Component Architectures
· Metadata Management
· Transaction and Query Processing in Distributed Information Systems
· Integration Architectures
· Mobile Web Information Systems Integration
· Case Studies
2. Web Engineering and Web Applications
· Internet & Web-based Systems
· Web-Based Applications
· Enterprise Security
· Data Intensive Applications on the Web
· XML and Semi-structured Data Management
· Web as Database versus Web as Documents
· Digital Libraries
· E-Government
· Agent Based Information Systems
· E-Learning
· Web Information System Environment and Foundations
· Data and Knowledge Engineering
· Applications
3. E-commerce and M-business
· E-commerce Architectures
· Online Payment
· Agent Mediated E-Commerce
· Trading & Auctioning Systems
· Mobile Commerce Models and Architectures
· Business Models for M-Business Applications
· Mobile Internet access
· Multimedia applications in E-Commerce
· E-Commerce framework & applications
· Intelligent agents
· EDI & XML
· Data mining
· Business intelligence
· Electronic brokerage
· Electronic negotiation
· On-line auction
· Industry applications
4. Intelligent Data and Information Retrieval
· Data Mining and Knowledge Discovery
· Multi/Cross-Lingual Data and Information Retrieval
· Multi-modal and Multimedia Data and Information Management
· Spatial and Temporal Data and Information Management
· Web Information Management
· Web Information Retrieval
· Web Mining and Farming
Programming Languages
The primary function of programming languages and tools has always been
to
make the programmer more productive. Appropriate programming languages
and
tools may drastically reduce the cost of building new applications as
well as maintaining existing ones. It is well known that programming
languages can greatly increase programmer productivity by allowing the
programmer to write highly scalable, generic, readable and maintainable
code. Moreover, new domain specific languages can be used to enhance
aspects of software engineering beyond coding such as: domain-specific
analysis, program management, visualization, testing, maintenance,
modeling, and rapid
prototyping. The development of these languages is itself a significant
software engineering task, requiring a considerable investment of time
and
resources. Domain-specific languages have been used in various domains
such as graphics, financial products, telephone switching systems,
protocols,
operating systems, hardware design, robot languages, etc. These
applications
have clearly illustrated the advantages of domain specific-languages
over
general purpose languages with respect to productivity, reliability, and
flexibility for the domains in question.
The purpose of the minitrack is to bring together an international
audience of researchers and practitioners actively involved in the
development of
domain-specific languages. The minitrack will focus principally on
practical issues such as design, implementation, and use of
domain-specific languages as an element of software engineering
practice.
Topics of interest for this mini-track are
(not exhaustive):
- design and implementation of domain-specific languages,
- use of domain-specific languages affecting the software engineering
process,
- role of domain-specific languages in software engineering,
- tools, environments, and techniques needed to support domain-specific
languages.
Intelligent Knowledge Management
Design and modeling aspects of the following Computational
Intelligence Techniques and their applications to science, technology,
commerce, social science and economics:
-Artificial Neural Networks and Probabilistic Reasoning
-Genetic Algorithms
-Evolution Strategies
-Genetic Programming
-Evolutionary Programming
-Learning Classifiers
-Fuzzy Systems including Fuzzy logic and possibility
theory, Fuzzy expert systems, Fuzzy system modeling
and simulation
-Hybrid Soft Computing Techniques like Neuro-Fuzzy,
fuzzy-GA, GA-Fuzzy etc.
-Intelligent Agents including Multi-Agents, Autonomous Agents
and Cooperative Agents
-Support Vector Machines
-Bayesian networks and probabilistic reasoning
-Rough sets
-Case-based Reasoning
*Data and Knowledge Representation: planning and description logics
*Data and knowledge visualization
*Knowledge acquisition
*Models and frameworks of Data Mining techniques
*Reasoning methods and technologies
*Knowledge and belief, belief revision and update, non-monotonic
formalisms, uncertainty
Rule Markup Languages
The workshop will focus on how rule markup languages, such as RuleML,
will contribute to the vision of the Semantic Web. The Semantic Web
offers a research perspective for automating business processes. Rule
markup languages, that allow to express business rules as modular,
stand-alone units in a declarative way, and to publish them and
exchange them between different systems and tools, will play an
important role for facilitating business-to-customer (B2C) and
business-to-business (B2B) interactions over the Web.
*Derivation rules* can be included in an ontology to define derived
concepts on top of base concepts. In this way, for instance, derived
business terms, such as customer categories, may be defined. Whenever
a rule refers to an incomplete predicate, for which explicit negative
information has to be represented along with ordinary (positive)
information, a second negation, supplementing negation-as-failure,
is needed (as in the formalism of extended logic programs). Using
this negation in the head of a rule, one can express conflicting
rules that may defeat each other. Such a language for *defeasible
rules* is useful to represent business rules allowing for exceptions.
In addition to derivation rules, there is another type of rule which
allows to specify the reactive and communicative behavior of a
system or agent: *Reaction rules* -- in other contexts also called
'event-condition-action (ECA) rules' or 'triggers'. Business rules
that specify the various steps of a business process can be encoded
in the form of reaction rules. A general markup language for business
rules has to accommodate these different types of rules and support
their interoperation.
Topics of Interest:
We encourage submissions on all topics related to rule markup
languages. In particular, we solicit papers on
* reaction rules on the Semantic Web
- event/action languages
- execution models
* defeasible rules on the Semantic Web
- defeasible concept definitions in ontologies
- resolving conflicts in triggered action sets
Testing
Topics of interest include:
* Testing Techniques
* Testing Process
* Test Automation
* Test Management
* Inspections, Reviews, and Walkthroughs
* Software Process Assessment and Improvement
* Web and e-Commerce Related Quality and Testing Issues
* Quality Management Issues
* Measurements and Benchmarking
* ISO 9000 Certification
* CMM and CMMI Experiences
* Configuration Management and Version Control
* Change Tracking
* Project Management
* Risk Assessment
* Requirement Management
* Automated Tools Dealing with any of these areas.
Fourth International Symposium on Multimedia Software
Engineering (MSE) is an international forum for multimedia
and software engineering researchers to exchange information
regarding advancements in the state of the art and practice
of multimedia software engineering, as well as to identify
the emerging research topics and define the future of multimedia.
The technical program of MSE2002 will consist of invited talks,
paper presentations, and panel discussion. Submission of high
quality papers describing mature results or on-going work are invited.
Topics for submission include but are not limited to
* Multimedia system architecture
* Multimedia streaming, networking, and QoS
* Multimedia meta-modeling techniques and operating systems
* Signal processing including audio, video, image processing, and coding
* Architecture specification languages
* Software development using multimedia techniques
* Multimedia tools including authoring, analyzing, editing, and browsing
* Multimedia user interfaces and interaction models
* Multimedia file systems, databases, and retrieval
* Multimedia collaboration
* Rich media enabled E-commerce
* Pervasive and interactive multimedia systems including mobile
systems and digital TV
* Computational intelligence including neural networks, fuzzy logic,
and genetic algorithms
* Intelligent agents for multimedia content creation, distribution,
and analysis
* Internet telephony and hypermedia technologies and systems
* Multimedia security including digital watermark and encryption
* Multimedia systems and applications in education and design
* Distributed multimedia systems and applications
Engineering and Deployment of Cooperative
Information Systems
In today's dynamic and competitive business and social environment, the
ability for an organization to cooperate with others flexibly, handling
changes properly and make full use of modern information technologies has
become very essential to its existence, competitiveness and prosperity.
Recent advances in such fields as computer-supported cooperative work,
workflow management, knowledge management and continuous software
engineering offer promising means for an organization to acquire this
ability. In particular, integrated uses of the technologies from these
fields have shown significant potential in establishing modern information
systems infrastructure.
With the event of EDCIS2002, we cater for a stimulating forum, in which
researchers and practitioners in related fields will get together to
exchange ideas and experiences. Hereby, we call for submission of papers
that are related to various aspects of cooperative information systems
engineering. The main topics of interest include, but are not limited to:
- Information Systems Infrastructures
- Middleware
- Enterprise Application Integration
- Enterprise Modeling
- Knowledge Management
- Organization and Resource Management
- Process Management
- Groupware and Workflow Management Systems
- Change Management and Systems Evolution
- Emergent Industrial Practices: E-Commerce and Virtual Enterprises
- Web Technologies / Web Services for Cooperative Information Systems
- Application of Coordination Theory
- Human-Computer Interaction
- Fundamentals and Application of Information Logistics
Information and Knowledge Management
Call for Papers
Symposium on Document Engineering 2002
The Symposium on Document Engineering (DocEng '02) is an academic
conference devoted to the dissemination of research on document
engineering. DocEng '02, the second annual meeting, seeks high-quality,
original papers and panels that address the theory, design, development,
and evaluation of computer systems that support the creation, analysis,
or distribution of documents in any medium.
We, the organizers of DocEng '02, hold to an expansive notion of
documents. A document is a representation of information designed for
reading by, or played-back to, a person. It may be presented on paper,
on a screen, or played through a speaker and its underlying
representation may be in any form and include data from any medium. A
document may be stored in final presentation form or it may be generated
on-the-fly, undergoing substantial transformations in the process. A
document may include extensive hyperlinks and be part of a large web of
information. Furthermore, apparently independent documents may be
composed, so that a web of information may itself be considered a document.
Conceptual topics and technologies relevant to the symposium include
(but are not limited to):
Document standards, models, representation languages
Document authoring tools and systems
Document presentation (typography, formatting, layout)
Document synchronization and temporal aspects
Document structure and content analysis
Document categorization and classification
Document internationalization
Integrating documents with other digital artifacts
Document engineering life cycle and processes
Document workflow and cooperation
Document engineering in the large
Document storage, indexing, and retrieval
Automatically generated documents
Adaptive documents
Performance of document systems
Markup languages (SGML, XML)
Style sheet systems and languages (CSS, XSL, DSSSL)
Structured multimedia (MPEG-4, SMIL, MHEG, HyTime)
Metadata (MPEG-7, RDF)
Document database systems and XQL
Optical character recognition
Type representations (Adobe Type 1, Truetype)
Page description languages (PostScript, PDF)
Electronic books (E-book) and digital paper
Applications of constraint systems for document engineering
Document transformation (XSLT)
Document services on wireless networks (WAP)
Document linking standards (XLink, XPath, XPointer)
Document APIs (SAX, DOM)
Multi-Agent Systems, Large Complex Systems,
and E-Businesses
http://www.com.gcal.ac.uk/international/MALCEB2002.htm
Real-Time Systems
The goal of the workshop is to bring together people from
industry and academia that are interested in all aspects of
timing analysis for real-time systems. The workshop will provide
a relaxed forum to present and discuss new ideas, new research
directions and to review current trends in this area. The
workshop will be based on short presentations that should
encourage discussion by the attendees.
The topics of the workshop include any issue related to timing
analysis, in particular:
o High-level code analysis
o Low-level timing analysis
o Timing analysis through measurement
o Modelling of processor features
o Probabilistic analysis techniques
o Integration of WCET and schedulability analysis
o Evaluation and case studies
o Tools for timing analysis
o Industry experience reports
Reverse Engineering
If you are involved in extracting information, artifacts,
architectural components (or anything else of value) from existing
systems - then you should be participating in this conference!
The Working Conference on Reverse Engineering (WCRE) is the premier
research conference on the theory and practice of recovering
information from existing systems. Now approaching its ninth
incarnation, we explore innovative methods of extracting the many
kinds of information that can be recovered from the data, software,
and other components that comprise systems, and to examine innovative
ways of using this information in system understanding, renovation,
and system reengineering.
In the last 10 years, there has been considerable progress in this
field, centered around WCRE. Reverse engineering has matured and
become a part of every practitioner's vocabulary, and student
textbook. It now represents a considerable body of knowledge.
Increasingly, the industry is formally incorporating reverse
engineering tools and techniques into our systems development
activities. WCRE plays the leading role in moving this research agenda
forward.
WCRE is truly a working conference, where discussion is emphasized. By
tradition, each paper presentation has a strict 20-minute limit.
Following each group of papers on a given topic, there is serious and
in-depth discussion of the topic area, the work described in the
presentations, and the implications for future research. WCRE
attendees are not passive observers; we are active participants in
discussing and shaping future directions of the Reverse Engineering
and Reengineering fields.
_________________________________________________________________
Topics
Topics discussed at WCRE include but are not limited to:
* Software maintenance and evolution
* Program analysis and slicing
* Decompilation & binary translation
* Refactoring
* Program comprehension
* Program transformations
* Software architecture extraction
* Cluster and concept analysis
* Requirements reengineering
* Object identification
* Software migrations
* Browsing & searching legacy sys.
* User interface reengineering
* Software visualization
* Web-enabling legacy systems
* XML, meta-data, and data-exchange
* Web-site reverse engineering
* Reverse engineering tool support
* Transitioning to product lines
* Documentation generation
* Data reverse engineering
* Formal methods for rev. eng.
* Experience reports
* Programming knowledge
* Reengineering patterns representations
* Collaborative reengineering efforts
* Requirements traceability
* Software process implications
* Dynamic analysis
* Reverse engineering economics
* UML and round trip engineering
* Preprocessing and parsing
* Software metrics
* Software components
Certification and Security in E-Services
Certifying the execution of an e-service provided on the network as the
result of the interaction among independent organizations is a critical
area for the underlying IT-infrastructure. In fact, given the legal value
that is often attached to data managed and exchanged during the execution
of such an inter-organizational e-service, being able to document what was
actually carried out is of the utmost importance. This is made more
complex in cases, like it often happens in the public administration
sector, where e-services are based on legacy systems managed by autonomous
and independent organizations.
Additionally, the whole area of security issues, from the more basic
ones (availability, authentication, integrity, confidentiality) to the
more complex ones (e.g., authorization, non-repudiation) is an equally
critical aspect to be able to trace down responsibilities ("who did
what"). This capability is mandatory to increase the presence and the
use of e-service IT-infrastructures.
The two areas have moreover a common technological intersection, since
both are based on the reliable and efficient monitoring of executed and
running processes. Certification and security are as well fundamental
processes in organizational and economic terms.
The objective of the workshop is to discuss technical and organizational
aspects regarding these two areas and their interrelations, presenting
both real-life application experiences and methodological proposals,
from participants belonging to the governmental, industrial and academic
communities.
The workshop is within the "Security" Stream of the IFIP-WCC 2002, the
17th World Computer Congress of the IFIP. This is a uniquely rich event
featuring 10 distinct Streams on key issues in Information Technology.
The "Security" Stream features also one tutorial "Introduction to
Computer Security" and one more Workshop "E-Government and Security",
thus providing even more opportunities for discussions about security
issues in IT-infrastructures in our increasingly digital world.
For more information on CSES 2002 visit the Workshop's web site at:
http://leonardo.dm.univaq.it/cses2002
========================================================================
Topics
========================================================================
Topics of interest include (but are not limited to):
- Traceability in e-services
- Certification in e-services
- Methods for guaranteeing non-repudiation in e-services
- Authentication and encryption in e-services
- Public Key Infrastructures
- Certification Authorities and management of trust
- Authorization and access control models for e-services
- Certification and security for mobile access to e-services
- User and e-service profiling
- Risks analysis methods (new approaches and experiences)
- Risks through interception and tracking technologies
- Information flow issues
- Firewall technology and e-services
- Administration and management of safeguards
- Security middleware solutions
- Secure electronic markets
- Messaging Security in e-services
- Web Security in e-services
- Security Issues in e-Services
- Multilateral Security
- Network Protocol Security
- Users' security responsibilities
- Protecting users/usees by Privacy-Enhancing Technologies
- Critical Information Infrastructure Protection and Social Implications
- Organizational issues in implementing security measures
An Evaluation of Modeling
The workshop provides a forum for researchers and practitioners interested
in modeling methods in systems analysis and design to meet, and exchange
research ideas and results. It also provides researchers an opportunity to
present their research papers and experience reports, and to take part in
open discussions. The seventh in a highly successful series of workshops,
EMMSAD'02 is jointly sponsored by the Conference on Advanced Information
Systems Engineering (CAiSE) and the International Federation for
Information Processing Working Group 8.1 (IFIP8.1).
Accepted papers:
Akhilesh Bajaj (Carnegie Mellon University, US): Measuring the effect of
number of concepts on the readability of conceptual models
Aldo de Moor (Tilburg University, NL): Evaluating methods for community
information systems development
Andrew Gemino & Yair Wand (Simon Fraser University, CA; University of
British Columbia, CA): Towards common dimensions in empirical comparisons
of conceptual modeling techniques
Bart'Jan Hommes (Delft Technical University, NL): Evaluating conceptual
coherence in multi modeling techniques
Colette Rolland & Mohamed Ben Ayed (Sorbonne University, FR): Understanding
the Lyee methodology through meta modeling
Dan Moody, Guttorm Sindre, Terje Brasethvik & Arne Solvberg (Monash
University, AU; NTNU, NO): Empirical testing of a conceptual model quality
framework
Graham McLeod & Dirk Roeleveld (Inspired, ZA; University of Capetown, ZA):
Method evaluation in practice: UML/RUP vs Inspired Method
Ilia Bider (IbisSoft, Stockholm, SE): Requirements on modeling techniques
for a new generation of business applications
J. Kabeli & P. Shoval (Ben-Gurion University, IL): A comparison of the FOOM
and OPM methodologies for user comprehension of analysis specifications
Joseph Barjis, Jan Dietz & Tychon Galatonov (Delft Technical University,
NL): Language based requirements engineering combined with Petri nets
Kalle Korhonen & Mirja Pulkkinen (University of Jyvaskyla, FI): A
comparative study on component functionality in metaCASE environments
Ken Lunn & Ann Lindsay (University of Huddersfield, GB): An object model to
support requirements development
Keng Siau & Poi-Peng Loo (University of Nebraska-Lincoln, US): Difficulties
in learning UML: a concept mapping analysis
Peter Bollen (University of Maastricht, NL): A formal transformation from
Object Role models to UML class diagrams
S. Maj & G. Kohli (Edith Cowan University, AU): B-nodes: a bridge between
the business model, information model and infrastructure model
Sofie de Flon Arnesen & John Krogstie (NTNU, NO; SINTEF, NO): Assessing
Enterprise Modelling Languages using a General Quality Framework
Tero Paivarinta (Agder University College, NO): Comparison of the
genre-based ISD approach to 11 others
Terry Halpin (Microsoft Corporation): Join constraints
Xiaomeng Su & Lars Ilbrekke (Norwegian University of Science and Technology
(NTNU), NO): A comparative study of ontology languages and tools
Zoran Stojanovic, Ajantha Dahayanake & Henk Sol (Delft University of
Technology, NL): A foundation of a component-oriented systems modeling
approach
Coordinated Applications
SCOPE AND TOPICS
Modern information systems rely more and more on combining
concurrent, distributed, mobile and heterogenous components. This
move from old systems, typically conceived in isolation, induces
the need for new languages and software architectures. In
particular, coordination languages have been proposed to cleanly
separate computational aspects and communication. On the other
hand, software architects face the problem of specifying and
reasoning on non-functional requirements. All these issues are
widely perceived as fundamental to improve software productivity,
enhance maintainability, advocate modularity, promote reusability,
and lead to systems more tractable and more amenable to
verification and global analysis.
The aim of the workshop is to bring together researchers working
on the foundations of component-based computing, coordination, and
software architectures. Topics of interest include (but are not
limited to):
o Theoretical models for coordination (component composition,
concurrency, dynamic aspects of coordination, semantics,
expressiveness);
o Specification, refinement, and analysis of software archi-
tectures (patterns and styles, verification of functional and
non-functional properties);
o Coordination, architectural, and interface definition languages
(implementation, interoperability, heterogeneity);
o Agent-oriented languages (formal models for interacting agents);
o Dynamic software architectures (mobile agents, configuration,
reconfiguration);
o Modeling of information systems (groupware, internet and
the web, workflow management, CSCW and multimedia applications)
o Coordination patterns (mobile computing, internet computing);
o Tools and environments for the development of coordinated
applications
Focused Software Process Improvement
Theme and Scope
===============
The main theme of PROFES is professional software process improvement (SPI)
motivated by product and service quality needs. SPI is facilitated by
software process assessment, software measurement, process modeling, and
technology transfer. It has become a practical tool for quality software
engineering and management.
The business of developing new applications like mobile and Internet
services or enhancing the functionality of a variety of products by
embedded software is maturing and meeting harsh business realities. The
need for professional software development, quality, and cost/effectiveness
is becoming evident and there is a need to spread SPI beyond its
traditional areas. Therefore, we encourage papers and discussions in new
application domains in addition to more traditional SPI papers. The
contributions may include quality issues related to processes, methods,
techniques, tools, enabling technologies and applications.
The purpose of the conference is to bring into the light the most recent
findings and results of the area and to stimulate discussion between the
researchers, experienced professionals and technology providers for SPI.
The large number of participants coming from industry confirms that the
conference provides a variety of up-to-date topics and tackles industry
problems.
Topics
======
The main topics of the conference include:
- Software Process Improvement
- Process Assessment
- Process Modeling
- Process Establishment
- Measurement
- Software Quality
- Quality Standards
- Methods and Tools
- Experimental Software Engineering
- Organizational Learning/Experience Factory
- People Issues
- Industrial Experiences and Case Studies
- Best practices
- Lessons Learned
Conceptual Modeling Quality
SCOPE OF THE WORKSHOP
Quality in conceptual modeling has been a topic of research since the early
nineties. After a relatively quiet period in the mid-nineties, a renewed
interest in conceptual modeling quality issues is observed. The theme of
IWCMQ'02 is methodologies and instruments for the quality assurance of
conceptual modeling processes and products. The workshop intends to provide
a forum for researchers and practitioners working on approaches, frameworks,
methods, techniques, guidelines, and tools for measuring, predicting,
evaluating, controlling, and improving the quality of conceptual modeling
processes and artifacts.
Conceptual modeling fulfills a bridge function with other disciplines such
as business process (re)engineering, requirements engineering, information
systems engineering, software engineering, and database design. Therefore
the workshop is not limited to a particular flavor of conceptual modeling.
It is open to work related to any type of 'real-world' requirements modeling
and analysis (e.g. domain modeling, business/enterprise modeling, conceptual
data modeling, process modeling, conceptual modeling of E-business/web-based
applications).
The main workshop goal is to assemble experts from diverse IT fields.
Currently there is no formal forum devoted to issues of conceptual modeling
quality. Another goal is therefore to establish a permanent network of
researchers and practitioners working in this domain. The concrete objective
of IWCMQ'02 is to sketch a field-overlapping state-of-the-art and
state-of-the-science of quality in conceptual modeling, identify possible
paths of collaboration, and point out future research directions.
We cordially invite researchers and practitioners to submit original
research, survey or experience papers to IWCMQ'02. All accepted papers will
be published in a volume of the Springer-Verlag LNCS series, that will
contain the proceedings of the ER'02 workshops.
TOPICS OF INTEREST
Submissions are invited, but not limited, to the following topics, organized
in four areas:
Theoretical Foundations of Conceptual Modeling Quality
* Quality criteria and frameworks for conceptual models
* Quality models for conceptual modeling processes
* Reference theories for conceptual modeling quality
* Quality standards applied to conceptual modeling
* Ontological correctness in modeling
* Consistency of conceptual modeling artifacts
* Goodness of transformation: real world - conceptual, conceptual -
physical, etc.
* Pragmatic quality of conceptual modeling artifacts
Assessing Conceptual Modeling Quality
* Quality checklists, rating instruments, and questionnaires
* Quality assessment based on expert/domain knowledge
* Subjective assessment instruments versus objective measures
* Measures of completeness, correctness, consistency, and coverage
* Cognitive complexity measures
* Size and structural complexity measures
* Pragmatic quality measures
* Quality assurance of modeling processes
* Comparative quality evaluation of conceptual modeling methods, notations
and processes
* Evaluating suitability of ontology to domain and/or audience
* Validation of measures
* Measurement collection tools
Evaluating Conceptual Modeling Quality
* Case studies or other real world experiences in conceptual modeling
quality
* Experiments in conceptual modeling quality
* Evaluation frameworks and threshold values for measures
* Benchmarking conceptual modeling quality
* Conceptual modeling quality and information system quality
* Conceptual modeling quality and database quality
* Indicators of conceptual modeling quality
* Prediction/estimation models for conceptual modeling quality
* Measurement analysis tools
Controlling and Improving Conceptual Modeling Quality
* Refactoring of conceptual modeling artifacts
* Schema transformations for improving quality
* Testing/inspecting conceptual modeling artifacts
* Quality guidelines for conceptual modeling
* Conceptual modeling process improvement
* Conceptual modeling method engineering
* Organizing the conceptual modeling quality assurance process
* Automating the conceptual modeling quality assurance process
Security of Communications on the Internet
TOPICS OF INTEREST
------------------
- Techniques and tools for intrusion detection: scenarios, stochastic
models,
behavioral approaches, immunology, alert correlation.
- Practical security: classification of risks and attacks, access
control.
- Cryptographic essentials: encryption algorithms, pseudo-random
generators,
digital signature.
- New cryptographic protocols and models, relationships between models,
formal
methods, security properties, authentication, secrecy, privacy,
anonymity,
semantics and verification algorithms.
- Applications and experimental evaluation of tools and techniques.
Knowledge Media Networking
New integrated services are emerging from the rapid technological advances
in networking, multi-agents, virtual environments, media and broadcasting
technologies. Several communities are appearing using a part or a
combination of these technologies and sharing virtual spaces. In the
future,
such virtual spaces will host a growing number of software agents that
look
after certain tasks and perform functions on behalf of their clients.
Computational devices and agents become part of furniture, walls, and
clothing; physical space provides a sense of place that would be augmented
towards knowledge space. The space must precisely understand its devices
and
their situation, in particular the computations they are performing, in
order to understand what individuals in the space are doing. This workshop
would provide a forum for researchers and practitioners involved in the
design and development of knowledge media networking spaces, agent
applications, knowledge management systems and 3D media architectures. It
is
expected that the workshop will promote a very intensive interaction among
those attending it, giving ample time to discuss papers. The Workshop
Proceedings will be published by IEEE Computer Society Press.
