|
|
Tutorials
|
|
 |
Seventh
International Conference on UML Modeling Languages
and Applications
<<UML>>
2004
October
10-15, 2004
Lisbon, Portugal
|
|
|
Note:
In all email addresses on this page, [at]
replaces @,
to prevent spam.
| T1
- Sun, Oct 10, morning |
Constructing
Tool-Support for Sophisticated Analysis of
UML Models: A Hands-On Introduction |
T2
- Sun, Oct 10,
afternoon |
MDA
Standards for Ontology Development |
| T3
- Mon, Oct 11, morning |
An
Overview of UML 2.0 |
| T4
- |
Guided
Inspection of UML Models (canceled) |
| T5
- Tue, Oct 12, morning |
Model-Centric
Enterprise Architecture |
| T6
- Tue, Oct 12, afternoon |
How
to design and use Domain Specific Modeling
Languages |
|
Tutorial
1:
Constructing
Tool-Support for Sophisticated Analysis of UML
Models: A Hands-On Introduction
Date:
|
Sunday
October 10, 2004 - morning (9:00 - 12:30) |
Presenter:
|
Jan
Jurjens
Software and Systems Engineering
TU Munich
Germany |
Abstract:
UML is now widely used as a notation to support
informal discussions between customers and developers,
and among developers, and for basic tasks such
as generating class definitions. There is, however,
a potential for a more far-reaching use of UML
within model-based development that could increase
efficiency and quality. This potential can be
realized by making a tool-supported use of the
UML models for
-
mechanical analysis of (potentially complicated)
system requirements on the model level (for
example by tool-bindings to model-checkers,
constraint solvers, automated theorem provers),
consistency checks etc.
- generation
of behavioral code from the models
- generation
of test-sequences for conformance testing
- mechanical
analysis of system configurations against UML
models
The
tutorial aims to give a hands-on introduction
to developing advanced tool-support for model-based
development with UML.
Participants will learn to create their own small
analysis application during the tutorial.
[back
to top]
|
|
Tutorial
2:
MDA
Standards for Ontology Development
Date:
|
Sunday
October 10, 2004 - afternoon (14:00 - 17:30) |
Presenters:
|
Dragan
Gaševic, Dragan Djuric and
Vladan Devedžic
FON - School of Business Administration,
Belgrade,
Serbia and Montenegro |
Abstract:
The Semantic Web is the main direction of the
future Web development. Domain ontologies are
the most important part of Semantic Web applications.
Artificial intelligence techniques are used for
ontology creation, but those techniques are more
related to research laboratories. Recently, there
are many proposals to use software engineering
techniques, especially the UML since it is the
most accepted software engineering standard, in
order to bring ontology development process closer
to wider practitioners' population. However, UML
is based on object oriented paradigm, and has
some limitation regarding ontology development.
These limitations can be overcome using UML's
extensions (i.e. UML profiles), as well as other
OMG's standards (i.e. Model Driven Architecture
- MDA). Currently, there is an initiative (i.e.
RFP) within the OMG aiming to define a suitable
language for modeling Semantic Web ontology languages
in the context of the MDA.
The
main goal of this tutorial is to present comprehensive
introduction into MDA-based ontology development.
It will provide an introduction to the field of
the Semantic Web and ontology engineering, a description
of several UML- and metamodeling- based solutions
and tools for ontology development, an overview
of the OMG's MDA effort and related standards
(Meta-Object Facility - MOF, UML, XML Metadata
Interchange - XMI), a detail overview of the OMG's
proposal for Ontology Definition Metamodel (http://ontology.omg.org).
Finally, we will describe our experiences in developing
and employing an MDA-based infrastructure for
ontology engineering we defined using the OMG's
recommendations.
[back
to top]
|
|
Tutorial
3:
An
Overview of UML 2.0
Date:
|
Monday
October 11, 2004 - morning (9:00 - 12:30) |
Presenter:
|
Bran
Selic
IBM Software Group - Rational Software
Ontario, Canada |
Abstract:
The first major revision of the UML standard,
UML 2.0, has recently been submitted for adoption
to the Object Management Group. This revision
was strongly influenced by the current heightened
interest in model-driven development methods.
This approach requires modeling languages that
are precisely defined and which can cope with
the complexities of large-scale software systems.
We start the tutorial with an explanation of the
essential characteristics of model-driven development
and how those are reflected in modeling languages.
This is followed by a brief objective critique
of the pros and cons of the current version of
UML. The formal requirements for UML 2.0 are reviewed
next. Finally, we examine the proposed revision
itself: its structure, its conceptual foundations,
and its salient new features. Since the presenter
was a direct participant in the definition of
the submission, the design philosophy and rationale
behind each aspect are clearly explained.
[back
to top]
|
|
Tutorial
4:
(CANCELED)
Guided
Inspection of UML Models
Date:
|
|
Presenter:
|
John
D. McGregor
Dept of Computer Science
Clemson University
USA |
Abstract:
There is widespread agreement that finding defects
as early in the development life cycle as possible
is cost-effective; however, there are few systematic
techniques for accomplishing this goal. Guided
inspection is an inspection technique that is
"guided" by test cases. By constructing
a "complete" set of test cases, the
guided inspection technique identifies elements
missing from the model as well as evaluating the
quality of those that are present. This tutorial
illustrates the technique using design models
created using the Unified Modeling Language. Checklists
designed for use at various points in a typical
development process assist the inspector in selecting
the most effective test cases.
Guided
Inspection has several benefits:
-
Objectivity - systematically selects test cases
to give all portions of the model equal coverage.
-
Traceability - links the faults detected back
to specific requirements
-
Testability - identifies portions of the design
that are complex and require much effort to
test.
[back
to top]
|
|
Tutorial
5:
Model-Centric
Enterprise Architecture
Date:
|
Tuesday
October 12, 2004 - morning (9:00 - 12:30) |
Presenter:
|
Desmond
D'Souza
Kinetium Inc.
Austin, TX
USA |
Abstract:
The architecture of an enterprise is described
by a set of models of that enterprise, expressing
key aspects of the business domains themselves,
the goals and challenges of the enterprise, it's
processes, people, and organizations, the software
applications and components that support it, the
software and hardware infrastructure they run
on, and the interrelationships, commonalities,
and standards across these. The main reason for
investing in an enterprise architecture is to
better understand the enterprise with its current
and ideal operating characteristics, in order
to best design, manage, and guide the evolution
of its supporting systems.
Enterprise architecture involves multiple viewpoints,
spanning business goals through technology platforms.
It must handle heterogeneous and overlapping systems,
short and long-term migration planning, medium
to large-grained components and applications,
and mixtures of logical and highly platform-oriented
views.
UML 2.0 and MDA provide facilities that help with
some aspects of enterprise architecture, but do
not address several others. In this tutorial we
will describe an approach to enterprise architecture,
based on models and their interrelationships,
and using UML 2.0 and ideas from MDA where appropriate.
[back
to top]
|
|
Tutorial
6:
How
to design and use Domain Specific Modeling Languages
Date:
|
Tuesday
October 12, 2004 - afternoon (14:00 - 17:30) |
Presenter:
|
Alan
Cameron Wills and Stuart Kent
Microsoft Corporation
Cambridge
UK |
Abstract:
Software development can be accelerated and made
more agile, by designing a language that is specialised
to model your domain of interest. A user interface,
a database queries, or a page layout is rarely
designed these days without using a language (and
supporting tools) specific to that purpose - a
language that may be textual or graphical or both.
A domain-specific language captures an ontology
of its domain; and each implementation (a generator,
interpreting engine, or simulator that executes
the language's statements) encapsulates a framework
of components and design patterns. This tutorial
will explain how to create and use domain specific
languages, and how to make this pattern more applicable
to narrower and more specialized domains. We will
discuss some related patterns such as adaptive
assembly, software product lines and model driven
development, and how these form an integrated
pattern language we call the "Software Factory".
Finally, we will explore in some detail techniques
for designing a domain specific language; and
look at the tools and processes that go along
with such a language.
[back
to top]
|
Info
The
call for tutorials
is now over.
Further
questions should be directed to the Tutorials
Chair, Ezra K. Mugisa (ezra.mugisa[at]uwimona.edu.jm).
[back
to top]
|
|
|
