[
Date Prev][
Date Next][
Thread Prev][
Thread Next][
Date Index][
Thread Index]
[
List Home]
|
[aspectj-users] AOSD 2003: Tutorial Program
|
AOSD 2003: TUTORIAL PROGRAM
2nd International Conference on
Aspect-Oriented Software Development
March 17 - 21, 2003
Boston, USA
http://aosd.net/conference
Hosted by Northeastern University
In Cooperation with ACM SIGPLAN and SIGSOFT
*****************************************
Early Registration Deadline: 14 Feb. 2003
*****************************************
Aspect-oriented software development provides means for systematic
identification, modularization, and composition of crosscutting
concerns. This second conference dedicated to AOSD is the premier
forum for the dissemination and discussion of AOSD ideas, for both
practitioners and researchers. The conference features high quality
introductory, intermediate, and advanced tutorials on leading
aspect-oriented languages, software product lines, model-driven
engineering with aspects, and integrating aspect technologies with
business software: databases, Web applications, Java RMI, and CORBA.
The tutorials will be held on Monday 17 March and Tuesday 18 March.
The tutorial program includes:
* Aspect-Oriented Programming with AspectJ
* JMangler: On-the-Fly Transformation of Java Class Files
* Hyper/J: Multi-Dimensional Separation of Concerns for Java
* Dynamic and Distributed Aspect-Oriented Programming with JAC
* Advanced Aspect-Oriented Programming with AspectJ
* Identifying and Modeling Aspects Using Domain Analysis Techniques
* Feature Oriented Programming for Product-Lines
* Aspect-Oriented Programming for Database Systems
* Model-Driven Engineering with Contracts, Patterns, and Aspects
All tutorials are half-day and are briefly summarized below. For full
information about the program, visit the AOSD 2003 conference Web site.
===============
Monday 17 March
===============
----------------------------------------
Aspect-Oriented Programming with AspectJ
----------------------------------------
Erik Hilsdale, Palo Alto Research Center
AspectJ is a seamless aspect-oriented extension to Java(TM). It can be
used to cleanly modularize the crosscutting structure of concerns such
as exception handling, multi-object protocols, synchronization,
performance optimizations, and resource sharing. This tutorial will
introduce aspect-oriented programming (AOP) and show how to use AspectJ
to implement crosscutting concerns in a concise, modular way.
-------------------------------------------------------
JMangler: On-the-Fly Transformation of Java Class Files
-------------------------------------------------------
Guenter Kniesel, University of Bonn
Michael Austermann, SCOOP Software GmbH
JMangler is a freely available framework for load-time transformation
of compiled Java programs. The transformation of byte code is a core
technology that can be used for a variety of purposes, including the
implementation of new AOSD languages and tools. This tutorial will
provide attendees with a thorough understanding of JMangler and Java
byte code transformation, from an AOSD perspective.
----------------------------------------------------------
Hyper/J: Multi-Dimensional Separation of Concerns for Java
----------------------------------------------------------
Peri Tarr, IBM T. J. Watson Research Center
Harold Ossher, IBM T. J. Watson Research Center
Stanley M. Sutton, Jr., NFA
Multi-dimensional separation of concerns (MDSOC) is an AOSD approach
that promotes flexible, powerful separation and integration of software
based on all kinds of concerns. MDSOC treats all concerns as
first-class and co-equal, including components and aspects, allowing
them to be encapsulated and composed at will. This tutorial describes
how to accomplish MDSOC with Hyper/J(TM) in the context of standard
Java(TM) development. It will demonstrate how Hyper/J addresses real
and pervasive problems in participants' own Java development.
------------------------------------------------------------
Dynamic and Distributed Aspect-Oriented Programming with JAC
------------------------------------------------------------
Renaud Pawlak, University of Lille
Lionel Seinturier, LIP6
Modern business systems run in open environments, often involve the
Web, and are often based on middleware such as CORBA and Java RMI.
Distributed applications are critical to businesses and must deal with
concerns such as data consistency, scalability, dynamic resource
discovery, fault tolerance, run-time maintenance, and remote version
updating. This tutorial presents JAC, a programming environment for
developing aspect-oriented, dynamically reconfigurable, distributed,
and Web-based software. JAC offers the programmer a set of concepts
for creating, manipulating, and composing aspects at run time within
distributed and changing environments.
================
Tuesday March 18
================
-------------------------------------------------
Advanced Aspect-Oriented Programming with AspectJ
-------------------------------------------------
Erik Hilsdale, Palo Alto Research Center
This tutorial will provide involved hands-on programming exercises that
both use some of AspectJ's advanced features, and feature AspectJ used
in advanced contexts. We will show how AspectJ can be used to solve
problems in instrumentation (including logging), testing, quality
management, and feature management. In addition, advanced parts of the
AspectJ design and implementation will be introduced, along with
discussions of possible future features.
-----------------------------------------------------------------
Identifying and Modeling Aspects Using Domain Analysis Techniques
-----------------------------------------------------------------
Mehmet Aksit, University of Twente
Lodewijk Bergmans, University of Twente
Although object-oriented design methods and programming languages offer
several advantages, experience has shown that effective composition of
software remains a difficult task. Aspect-oriented techniques can help
to manage such software complexity, and "best practices" are beginning
to emerge for applying these techniques to both new and existing
software. This tutorial will describe these practices by (1) providing
guidelines for identifying aspects and (2) presenting approaches to
modeling and implementing aspects with current AOSD technologies.
----------------------------------------------
Feature Oriented Programming for Product-Lines
----------------------------------------------
Don Batory, University of Texas at Austin
Feature Oriented Programming (FOP) is both a design methodology and
supporting tools for program synthesis. The goal is to specify a
program in terms of the features that it offers, and to synthesize an
efficient program that meets these specifications. FOP and AOP are
complementary, as both aspects and feature refinements encapsulate
cross-cuts. This tutorial reviews basic results on FOP, including
general models and tools for synthesizing a consistent set of code and
non-code artifacts, with special focus on synthesizing product-lines of
product-families.
------------------------------------------------
Aspect-Oriented Programming for Database Systems
------------------------------------------------
Awais Rashid, Lancaster University
Database systems are central to the day-to-day functioning of most
businesses, but are notoriously costly to design and maintain. Like
other software, database systems are subject to many crosscutting and
overlapping concerns at both the design and implementation levels.
This tutorial will describe how AOP can be applied to address
crosscutting concerns in database systems in order to make them more
customizable, evolvable, and maintainable.
--------------------------------------------------------------
Model-Driven Engineering with Contracts, Patterns, and Aspects
--------------------------------------------------------------
Jean-Marc Jezequel, IRISA
An application's "non-functional" aspects - such as persistence, fault
tolerance, and quality of service - should be separate from that
application's functional aspects. UML-based tools can help to untangle
these parts and map from aspect models to implementations. In this
tutorial, we show how to organize models around (1) quality of service
contracts for specifying non-functional aspects and (2) aspects for
describing how those contracts can be implemented. We show how to
model contracts with a small set of stereotypes, and how to represent
aspects and applications of design patterns at the meta-model level.
