The ICSE tutorial program provides conference participants
with the opportunity to gain new insights, knowledge, and skills in a broad
range of areas of software engineering. Tutorials will be held on 16 and 17
May 2005 (Monday and Tuesday during ICSE). See the details below associated
with each tutorial to identify the times of each full or half day tutorial.
Note: All tutorials
will follow the ICSE '05 standard
daily schedule.
F1 |
|
|
Rules of Thumb
for Secure Software Engineering |
F2 |
|
|
The Software Engineering
of Agent-Based Intelligent Adaptive Systems |
F3 |
|
|
Spiral Development of Software-Intensive
Systems of Systems |
H1
|
|
|
Financially Informed Requirements
Prioritization |
H2
|
|
|
Component-Based Software
Engineering for Embedded Systems |
H3
|
|
|
Story Driven Modeling -
A Practical Guide to Model Driven Software Development |
H4
|
|
|
Understanding Metamodeling |
H5
|
|
|
Software Visualization |
H6
|
|
|
Engineering Safety-Related
Requirements for Software-Intensive Systems |
H7
|
|
|
Model-Based Testing |
H8
|
|
|
Reverse Engineering of Object-Oriented
Code |
H9
|
|
|
An Architect's
Guide to Enterprise Application Integration with J2EE and .NET |
H10
|
|
|
Transformations of Software
Models into Performance Models |
H11
|
|
|
Aspect-Oriented Programming |
H12
|
|
|
What You always Wanted to
Know about Agile Methods But Did Not Dare to Ask |
F1: Rules of Thumb for Secure Software Engineering
Holger Peine (Fraunhofer IESE, Kaiserslautern, Germany)
16 May 2005 - Monday - Full Day
Director's Row #48 [Floor
Plan]
Abstract:
This tutorial will teach important
guiding principles to avoid security problems in the design and implementation
of
software.
It does not address finding security problems in existing systems. No specific
technology is taught, but general principles of good security engineering.
We start with a short refresher on software security, motivated by a small
piece of real-world software (a Java applet for login) found insecure.
The main part of the tutorial will then present 20 rules of secure software
development in the form of Do's and Dont's, such as "Make components
with differing privileges" or "Validate data from lower-privileged
sources". Each rule is illustrated by examples of good and bad practice,
and by discussions of inherent problems and possible trade-offs against other
goals of software development. The audience is invited to contribute their
own experience in these discussions. We will continue with some considerations
on the general benefits and limitations of such a rule-based approach.
Finally, the initial example of the login application is revisited, and the
audience is invited to critique the applications design in the light of the
new knowledge. The tutorial will close with a short direction to security
patterns as "the next step" from the general rules.
Presenter's Biography:
Dr. Holger Peine received a diploma in computer
science ("with distinction")
and worked as a research assistant at Kaiserslautern University of Technology
(Germany), doing research in operating systems, distributed systems, networking,
and security. He received a Ph.D. in computer science ("with distinction")
for his award-winning research in run-time support for mobile code, and was
the designer and principal implementer of the Ara platform for secure execution
of general mobile code.
Following this, he joined the IT security department at the Fraunhofer IESE
research institute in Kaiserlautern, developing tools for the security evaluation
of IT systems and performing security evaluations of software, systems and
processes. Lately he became the lead of a newly-founded task force researching
techniques and tools for the development of secure software.
F2: The Software Engineering of Agent-Based Intelligent Adaptive Systems
Leon Sterling, Thomas Juan (University of Melbourne, Australia)
16 May 2005 - Monday - Full Day
Director's Row #47 [Floor
Plan]
Abstract:
Future software systems will be intelligent and adaptive, and will have the ability
to seamlessly integrate with smart applications that have not been explicitly
designed to work together. Traditional software engineering approaches offer
limited support for the development of intelligent systems. To handle the tremendous
complexity and the new engineering challenges presented by intelligence, adaptiveness
and seamless integration, developers need higher-level building blocks, or development
constructs. Agent concepts are natural to describe intelligent adaptive systems.
Agent based technologies and software engineering techniques have benefited significantly
from recent research in software engineering and have matured to offer useful
insights and concrete practices to mainstream software engineers.
This tutorial presents the state of the art in agent research from a software
engineering perspective, focusing on practices that are applicable today. We
will walk the audience through analysis, design and verification of a portion
of a real-world problem: a Smart Home Network. We show how agent concepts more
naturally match the engineering challenges of such systems like trust between
adaptive components. The audience will have hands-on experience with analyzing
and designing parts of the Smart Home Network and receive a detailed ROADMAP
on how to incorporate agent technologies into their current projects.
Presenters' Biography:
Leon Sterling serves
as Adacel Chair of Software Innovation and Engineering at the University
of Melbourne since 2002. He has a B.Sc.(hons.) from Melbourne
in 1976, and a Ph.D. from Australian National University in Canberra
in 1981. His overseas academic career includes three years at the University
of Edinburgh, U.K., one year at the Weizmann Institute, Israel, and ten
years at Case Western Reserve University, USA. He returned to Australia
in 1995, and served as Head of the Computer Science and Software Engineering
Department at the University of Melbourne for almost six years. His research
interests include software engineering, agent technology, logic programming,
and artificial intelligence. He has represented Software Engineering
in
several forums, including serving on the joint Board on Software Engineering
of Engineers Australia and the Australian Computer Society. He has published
widely, including popular books such as "The Art of Prolog" and "The
Practice of Prolog".
Thomas
Juan received a bachelor of engineering (software) and a bachelor
of science from the University of Melbourne. He is currently finishing his
PhD at the same university. His work in the area of Agent Oriented Software
Engineering has been well regarded in the AOSE community. He presented a
tutorial on Agent Oriented Software Engineering with Leon Sterling at 2004
IEEE/WIC/ACM International Joint Conference on Intelligent Agent Technology
(IAT'04).
F3: Spiral Development of Software-Intensive
Systems of Systems
Barry Boehm, A. Winsor Brown (University of Southern California, USA), Richard
Turner (George Washington University, USA)
17 May 2005 - Tuesday - Full Day
Director's Row #43 [Floor
Plan]
Abstract:
Commercial, public service, and national security organizations are finding
it increasingly attractive to integrate component system capabilities
from many
different "best of breed" sources to achieve their objectives. In
doing so, they find that they are increasingly dependent on software to integrate
the
systems and to rapidly adapt them in response to competitive opportunities
or threats, new technologies, or new organizational priorities.
The resulting software-intensive systems of systems (SISOS) offer significant
benefits, but come with significant new types of risks, such as simultaneous
satisfaction of multiple stakeholders and quality attributes, and integration
and rapid adaptation of multiple heterogeneous software products and COTS products.
This tutorial provides software engineers, managers and researchers with an
understanding of and emerging capabilities for practicing "Software engineering in the
very large". It identifies the major opportunities and risks involved
in software-intensive systems of systems, presents experience-based techniques
for
realizing the opportunities and mitigating the risks. It provides extensions
of the risk-driven spiral model that are being used for SISOS development processes,
and provides case study exercises to give participants experience in applying
the techniques in representative situations.
Presenters' Biography:
Dr. Barry Boehm is TRW Professor of Software Engineering and Director,
USC Center for Software Engineering. His contributions to the field include
the Constructive Cost Model (COCOMO), the Spiral Model of the software
process, the Theory W (win-win) approach to software management and requirements
determination. He is a Fellow of the primary professional societies in
computing (ACM), aerospace (AIAA), electronics (IEEE), and systems engineering
(INCOSE), and a member of the U.S. National Academy of Engineering.
A.
Winsor Brown, Assistant Director of the USC Center for Software Engineering,
has over 25 years of experience in software development, engineering and
management gained in aerospace, industrial and commercial applications. He
is a co-author with Barry Boehm of the book Software Cost Estimation with
COCOMO II.
Dr.
Richard Turner is a Research Professor in Engineering Management and
Systems Engineering at the George Washington University. In support of the
U.S. Department of Defense, he supports identifying and transitioning new
software technology into software-intensive defense systems. He was on the
CMMI development team and is a co-author of CMMI Distilled, as well as a
co-author with Barry Boehm of Balancing Agility and Discipline.
H1: Financially Informed Requirements Prioritization
Jane Cleland Huang (DePaul University, Chicago, USA), Mark Denne (Veritas,
USA)
16 May 2005 - Monday - Morning
St. Louis Ballroom F [Floor
Plan]
Abstract:
This tutorial introduces a financially responsible approach to requirements
prioritization that enhances the value creating potential of a systems
development project.
The approach which is part of the Incremental Funding Method (IFM), is described
in the book "Software by Numbers: Low-risk, High-Return Development".
Tutorial attendees will learn how to decompose a system into "chunks" of
revenue-generating functionality known as Minimal Marketable Features (MMFs),
to carefully sequence those MMFs in order to maximize the overall value of
the project, and to manipulate other project metrics such as reducing the initial
funding investment, or decreasing the time to reach break-even status. A gentle
introduction to financial analysis will also equip participants to analyze
and
understand the impact of other requirements prioritization decisions upon the
financial returns of a project. IFM is equally effective in both traditional
and agile software development environments.
This tutorial is particularly relevant to software development professionals
and project managers interested in getting more value from their projects, and
also for academics wanting to learn financial analysis skills that can be applied
in a general software engineering environment.
Presenters'
Biography:
Dr. Jane Cleland-Huang is
an Assistant Professor at DePaul University's School of Computer Science,
Telecommunications, and Information Systems. Her research
interests include Value-based Software Engineering, Requirements Traceability,
and Process Models. She is Associate Director of the Institute of Software
Engineering in Chicago, and director of the DePaul Center for Applied Requirements.
She has published peer reviewed papers on requirements traceability and
software development and recently coauthored the book "Software by Numbers: Low-risk,
High-Return Development", which describes a financially informed approach
to software development. Dr.Cleland-Huang is a member of the IEEE Computer
Society and has a PhD from the University of Illinois at Chicago.
Mark Denne is a Senior Principal at Veritas Software. He leads Veritas'
Utility Computing consultancy team in the USA. Prior to this he was at Sun
Microsystems for 10 years, where his roles included (i) overseeing the creation
of business and infrastructure solutions for Grid Computing, (ii) managing
the New York City Java Center, leading Java architects and designers working
with financial services and media clients, and (iii) being Sun's chief architect
for Citibank's financial services portal, now "Citibank Onlin",
voted "best online banking site" by Forbes Magazine and "best
financial portal" by Yahoo.
He has a Masters Degree in Computer Science from Cambridge University. His
book "Software by Numbers: Low-risk, High-Return Development",
published by Prentice Hall and co-authored by Jane Cleland-Huang, documents
radical new financial models for profitable low-risk software development.
He lives and works in Mountain View, CA.
H2: Component-Based Software Engineering for
Embedded Systems
Ivica Crnkovic (Mälardalen University, Sweden)
16 May 2005 - Monday - Afternoon
St. Louis Ballroom F [Floor
Plan]
Abstract:
Component-based development (CBD) is established as a standard approach in many
domains. Although attractive, CBD has not been widely adopted in domains of embedded
systems. Embedded systems are computer systems that are parts of larger systems
providing with services these systems. They vary from ultra small devices to
large distributed systems. The experience has shown that existing technologies
cannot be directly used for development of embedded systems. The main reason
is inability of these technologies to cope with the important concerns of embedded
systems, such as resource constraints, real-time or dependability requirements.
However an increasing understanding of principles of CBD makes it possible to
utilize these principles in implementation of different component-based models
more appropriate for embedded systems. The aim of this tutorial is to point to
the opportunity of applying this approach for development and maintenance of
embedded systems. The tutorial gives insights into basic principles of CBD, the
main concerns and characteristics of embedded systems and possible directions
of adaptation of component-based approach for these systems. Different types
of embedded systems and approaches for applying CBD are presented and illustrated
by examples from research and practices. Also, challenges and research directions
of CBD for embedded systems are discussed.
Presenters'
Biography:
Ivica Crnkovic is
a professor of industrial software engineering at Mälardalen
University, Sweden. He is the author of more than 50 refereed papers on software
engineering topics and a co-author and co-editor of two books: "Building
Reliable Component-Based Systems", and "Implementing and Integrating
Product Data Management and Software Configuration Management". He has
been co-program chair and co-organizer of several workshops and conferences
related
to component-based software engineering such as CBSE 2004 symposium, CBSE3-CBSE6
workshops at ICSE conferences, Euromicro conference CBSE tracks 2000-2004,
etc. He is participating in several research projects related to component-based
development
and embedded systems (PACC SEI/CMU project in cooperation with ABB Robotocs,
ARTIST Network of excellence, Swedish Foundation for Strategic Reseach project
SAVE, etc.). Prof. Crnkovic is teaching several undergraduate and graduate
courses in software engineering and component-based software engineering. He
also held
tutorials, seminars and specialized courses at different conferences, events
or industrial events.
H3: Story
Driven Modeling - A Practical Guide to Model Driven Software Development
Albert Zündorf (Universität Kassel, Germany)
16 May 2005 - Monday - Morning
St. Louis Ballroom A [Floor
Plan]
Abstract:
The Rational Unified Process lacks practical guidance for the development of
object oriented applications. Model Driven Software Development (MDD) proposes
to do most of these development steps at the model level of abstraction. This
tutorial takes the MDD idea and examplifies such a development process. The tutorial
guides the user from textual requirements descriptions through UML scenario modeling
to the derivation of test case specifications, class diagrams and UML behavior
models and finally to the implementation of the desired system. The tutorial
employs a running example that allows to illustrate the modeling activities for
each development phase and the guidelines for each modeling step. We discuss
how existing CASE tools may be used in such an approach and how the Fujaba environment
supports our development process.
Presenters'
Biography:
Albert Zündorf has
studied Computer Science at RWTH Aachen University, Germany from 1984 until
1990. In 1994 he finished his PhD still at RWTH Aachen.
Then he spent 6 years at University of Paderborn doing his Habilitation.
After 2 years as a step-in Professor at University of Braunschweig he has
become
a full professor for software engineering at University of Kassel in 2002.
Albert Zündorf is initiator and one of the technical leaders of the
Fujaba CASE tool project.
H4: Understanding Metamodeling
Thomas Kühne (TU Darmstadt, Germany)
16 May 2005 - Monday - Afternoon
St. Louis Ballroom A [Floor
Plan]
Abstract:
Metamodeling not only directly underpins the specification of modeling
languages such as the UML, but is also the foundation for making the
OMG's MDA vision come
true. This tutorial starts by motivating metamodeling as an advanced way of
creating software and then goes on to explore its fundamental principles.
In particular,
important new metamodeling concepts such as the distinction between ontological
and linguistic instance-of relationships, the unification of class and object
facets and deep instantiation are introduced. A metamodeling framework suitable
for MDA is constructed step-by-step and then used to explain and critique the
OMG's various metamodeling technologies. This information furnishes modelers
with the heuristics they need to more effectively utilize OMG metamodeling
technology and to know when metamodeling concepts are suitable and when
they are not. The
tutorial ends with some methodological advice on how to model in the presence
of more than two modeling levels (objects & classes).
Presenters'
Biography:
Thomas
Kühne is an Assistant Professor at the Darmstadt University of Technology.
Prior to that he was an Acting Professor at the University of Mannheim and before
that a researcher at the University of Kaiserslautern and a Lecturer at Staffordshire
University (UK). His interests are centered on object technology, programming
language design and metamodeling. He received a Ph.D. and M.Sc. from the Darmstadt
University of Technology, Germany in 1998 and 1992 respectively. Prof. Kuehne
can draw from considerable presentation and teaching experience especially
from courses held at Staffordshire University. In particular, Dr. Kuehne already
has given a full course on metamodeling at the Darmstadt University of Technology.
H5: Software Visualization
Stephan Diehl (Katholische Universität Eichstätt, Germany)
16 May 2005 - Monday - Morning
Director's Row #46 [Floor
Plan]
Abstract:
This half-day tutorial gives an overview of the current state-of-the-art in software
visualization. Software visualization encompasses the development and evaluation
of methods for graphically representing different aspects of software, including
its structure, its execution, and its evolution. In contrast to visual programming
and diagramming for software design, software visualization is not so much concerned
with the construction, but with the analysis of programs and their development
process. Software visualization combines techniques from areas like software
engineering, programming languages, data mining, computer graphics, information
visualization and human-computer interaction. Topics covered in this tutorial
include static program visualization, algorithm animation, visual debugging,
as well as the visualization of the evolution of software. In particular we identify
common principles illustrated by many examples and give pointers to tools available
today.
Presenters'
Biography:
Stephan Diehl is
a full professor for computer science at Catholic University Eichstätt.
He studied computer science and computational linguistics at Saarland University,
and as a Fulbright scholar at Worcester Polytechnic Institute,
Massachusetts. He got his PhD from Saarland University as a scholar of the
German Research Foundation (DFG) working in the group of Prof. Reinhard Wilhelm.
Stephan
Diehl's research interests include programming languages and compiler design,
web technologies, educational software and visualization, in particular software
visualization. He teaches courses on software visualization at university as
well as in industry and has been heavily involved in various international
software visualization related events.
H6: Engineering Safety-Related Requirements for
Software-Intensive Systems
Donald G. Firesmith (Software Engineering Institute, Pittsburgh, USA)
16 May 2005 - Monday - Afternoon
Director's Row #46 [Floor
Plan]
Abstract:
Many software-intensive systems have significant safety ramifications,
and inadequate requirements are a major cause of accidents involving
such systems. Yet, there
is too little interaction and collaboration between the requirements and safety
communities. Most requirements engineers and safety engineers know little about
each others’ discipline. Also, safety engineering usually concentrates
on architecture and design rather than requirements because hazard analysis
typically involves system components, the failure of which could cause accidents.
This
results in safety-related requirements that are ambiguous, incomplete, and
even missing.
This tutorial covers the basic concepts of safety engineering including hazards,
safety risks based on harm severities and likelihood of hazards / accidents,
safety integrity levels (SILs), and safety assurance evidence levels (SEALs).
The tutorial
then discusses the four major kinds of safety-related requirements including
safety requirements (a form of quality requirement based on safety as a factor
in a quality model), safety-significant requirements (including safety-critical
functional, data, interface, and non-safety quality requirements), requirements
for safety subsystems, and safety constraints. Techniques are provided for engineering
these requirements as well as associated examples. Next a process is provided
for engineering safety-related requirements. Finally, attendees will be led through
the engineering of the different kinds of safety-related requirements for an
example safety-critical system.
Presenters'
Biography:
Donald Firesmith is a senior member of the technical staff at the Software Engineering
Institute (SEI), where he works in the Acquisition Support Program helping the
United States Department of Defense acquire large complex systems of software-intensive
systems. With over 25 years of industry experience, he has published 5 software
engineering books, primarily in the areas of process and object orientation.
He is currently working on a book on the engineering of safety-related requirements
for software-intensive systems. He has published dozens of technical articles
and spoken at numerous conferences as well as been the program chair or on the
program committee of several conferences. Over the last four years, he has developed
a website (www.donald-firesmith.com) documenting the world's largest repository
and class library of free reusable, open-source process components, which process
engineers can use to create project-specific processes (methods).
H7: Model-Based Testing
Alexander Pretschner (ETH Zürich, Switzerland)
17 May 2005 - Tuesday - Morning
Director's Row #47 [Floor
Plan]
Abstract:
Model-based testing has become increasingly popular in recent years. Major reasons
include (a) the need for quality assurance for increasingly complex systems,
(b) the emerging model-centric development paradigm (e.g., UML and MDA) and its
seemingly direct connection to testing, and (c) the advent of test-centered development
methodologies.
Model-based testing relies on execution traces of behavior models. They are used
as test cases for an implementation: input and expected output. This complements
the ideas of model-driven testing. The latter uses static models to derive test
drivers to automate test execution. This assumes the existence of test cases,
and is, like the particular intricacies of OO testing, not in the focus of this
tutorial.
We cover major methodological and technological issues: the business case of
model-based testing within model-based development, the need for abstraction
and inverse concretization, test selection, and test case generation. We (i)
discuss different scenarios of model-based testing, (ii) present common abstractions
when building models and their consequences for testing, (iii) explain how to
use functional, structural, and stochastic test selection criteria, and (iv)
describe today's test generation technology.
We provide both practical guidance and a discussion of the state-of-the-art.
Potentials of model-based testing in practical applications and future research
are highlighted.
Presenters'
Biography:
Alexander Pretschner is a senior research associate with the chair for Information
Security at ETH Zurich, Switzerland. Master's degrees in computer science from
RWTH Aachen, Germany, and the University of Kansas, as a Fulbright scholar. PhD
on model-based testing of reactive systems from TU Munich, Germany. 35 papers
on model-based testing and development, CASE support, discrete-continuous systems,
and personalization in international journals and conference/workshop proceedings.
Co-organization of a 2004 international Dagstuhl seminar on model-based testing;
co-organization of ICSE 04 and 05 workshops on SW engineering for automotive
systems. Industrial projects on testing with BMW, EADS-M, Siemens, and Giesecke+Devrient.
Member of the program committee of a dozen international conferences and workshops.
Research interests include testing, model-based development, information security,
and the application of formal methods in industry. Current research focus in
model-based testing on re-usable test case specifications, modeling methodology,
and empirical investigations.
H8: Reverse Engineering of Object-Oriented Code
Paolo Tonella (ITC-irst, Povo, Italy)
17 May 2005 - Tuesday - Afternoon
Director's Row #47 [Floor
Plan]
Abstract:
During software evolution, programmers devote most of their effort to the understanding
of the structure and behavior of the given system. For Object-Oriented code,
this comprehension task might be particularly hard, due to the typically high
usage of delegation, resulting in multiple, scattered entities contributing to
the same function. Design views offer an invaluable help, but they are often
not aligned with the code, when they are not missing at all. Reverse engineering
of these views from the code is thus an appealing option in such a context.
This tutorial describes some of the most advanced techniques that can be employed
to reverse engineer several design views from the source code. The recovered
diagrams, represented in UML (Unified Modeling Language), include class, object,
interaction (collaboration and sequence), state and package diagrams. A unifying
static code analysis framework used by most of the involved algorithms is presented
at the beginning of the tutorial. A single running example is referred all over
the presentation, in order to clarify the mechanics of the various techniques.
Trade-offs (e.g., static vs. dynamic analysis), limitations and expected benefits
are also discussed.
Presenters'
Biography:
Paolo Tonella received
his laurea degree cum laude in Electronic Engineering from the University of
Padua, Italy, in 1992, and his PhD degree in Software
Engineering from the same University, in 1999, with the thesis "Code Analysis
in Support to Software Maintenance". Since 1994 he has been a researcher
of the Software Engineering group at ITC-irst, Trento, Italy. He participated
in several projects on software analysis and testing.
Paolo Tonella published over 20 journal papers, 4 book chapters, and 30 conference
papers. He is in the Steering Committee of SCAM (General Chair of SCAM 2005)
and WSE, and in the Program Committee of IWPC. He regularly reviews papers
for journals, among which the IEEE Transactions on Software Engineering. At
the beginning
of 2005, Springer-Verlag will publish the book: P. Tonella and A. Potrich, "Reverse
Engineering of Object Oriented Code" ISBN: 0-387-40295-0, containing most
of the material presented in this tutorial.
H9: An Architect's Guide to Enterprise Application
Integration with J2EE and .NET
Ian Gorton (National ICT, Australia), Anna Liu (Microsoft, Australia)
17 May 2005 - Tuesday - Morning
Director's Row #48 [Floor
Plan]
Abstract:
Architects are faced with the problem of building enterprise scale information
systems, with streamlined, automated internal business processes and web-enabled
business functions, all across multiple legacy applications. The underlying architectures
for such systems are embodied in a range of diverse products known as Enterprise
Application Integration (EAI) technologies.
In this tutorial, we highlight some of the major problems, approaches and issues
in designing EAI architectures and selecting appropriate supporting technology.
The tutorial presents a range of the common architectural patterns frequently
used for EAI applications. It also explains Service Oriented Architectures as
the current best practice architectural framework for EAI. It then describes
the state-or-the-art in EAI technologies that support these architectural styles,
and discusses some of the key design trade-offs involved when selecting an appropriate
integration technology (including buy versus build decisions).
Presenters'
Biography:
Ian Gorton is a Senior Researcher at National ICT Australia. Until Match 2004
he was Chief Architect in Information Sciences and Engineering at the US Department
of Energy's Pacific Northwest National Laboratory. Previously he has worked at
Microsoft and IBM, as well as in other research positions. His interests include
software architectures, particularly those for large-scale, high-performance
information systems that use commercial off-the-shelf (COTS) middleware technologies.
He received a PhD in Computer Science from Sheffield Hallam University.
Anna
Liu is an architect advisor at Microsoft Australia. She evangelizes
architecture and works with large enterprises in understanding and solving
their enterprise application integration challenges. Her interests include
designing and implementing robust service oriented architectures, and distilling
patterns and best practices. She has previously held a visiting scientist
position at the Software Engineering Institute, Carnegie Mellon University.
She received a PhD in Computer Engineering from the University of New South
Wales, Australia.
H10: Transformations of Software Models into
Performance Models
Vittorio Cortellessa, Antinisca Di Marco, Paola Inverardi (Università dell'Aquila,
Italy)
17 May 2005 - Tuesday - Afternoon
Director's Row #48 [Floor
Plan]
Abstract:
It is widely recognized that in order to make performance validation an
integrated activity along the software lifecycle it is crucial to be
supported from automated
approaches. Easiness to annotate software models with performance parameters
(e.g. the operational profile) and automated translations of the annotated
models into "ready-to-validate" models are the key challenges
in this direction. Several methodologies have been introduced in the
last few years to address these
challenges. The tutorial introduces the attendance to the main methodologies
for annotating and transforming software models into performance models. The
tutorial roadmap is as follows: (i) we introduce the topic and place it within
the wider domain of non-functional validation of software systems; (ii) we
describe the methodologies to annotate and transform models; we support
this description
by using a common simple case study to show them at work as well as to emphasize
their similarities/differences; (iii) we classify the methodologies basing
on different dimensions and parameters; (iv) finally, we give some ideas
about the
future directions in this research area.
Presenters'
Biography:
Vittorio Cortellessa holds
a Laurea in Computer Science from University of Salerno (1991) and a Ph.D.
in Computer Science from University of Roma "Tor Vergata" (1995).
He was a Post-doc fellow at the European Space Agency (ESRIN, 1997) and a Post-doc
at University of Roma "Tor Vergata"(1998-1999). From 2000-2001, he
was Research Assistant Professor at CSEE, West Virginia University, and Research
Contractor at DISP, University of Roma "Tor Vergata". Since 2002
he has been an Assistant Professor at University of L'Aquila (Italy). He has
been
involved in several research projects in the areas of performance analysis
of software/hardware systems, component-based software systems, fault-tolerant
systems
and parallel discrete event simulation, which are his main research areas.
He serves as a referee for conferences and journals in these areas.
Antinisca
Di Marco is a Ph.D. Student in Computer Science at University
of L'Aquila. She graduated in Computer Science at the University of L'Aquila
in 2001. Her main research interests are: Software Architecture, Software
Performance Analysis, Integration of Functional and Non-functional software
validation. She is interested in predictive performance analysis of Software
Architecture (SA). She is also interested in integrating the results of different
analyses made on SA in order to support validation and verification of SAs,
as well as in techniques to dynamically manage the performance of software
systems at run time through monitoring, reconfiguration and performance model
evaluation.
Paola
Inverardi is a professor at the Computer Science Department at University
of L'Aquila. Her research interests are in the field of the application of
formal techniques to the development of software systems. These include software
specification and verification of concurrent and distributed systems, deduction
systems, and Software Architectures. Current research interests mainly concentrate
in the field of software architectures specifically addressing the verification
and analysis of software architecture properties, both behavioral and quantitative.
On these topics she collaborates with several national and international
companies. Recently she is working on the design and development of mobile
applications.
H11: Aspect-Oriented Programming
Gregor Kiczales (University of British Columbia, Vancouver, Canada)
17 May 2005 - Tuesday - Morning
Director's Row #46 [Floor
Plan]
Abstract:
Aspect-oriented programming (AOP) is changing the way software is developed.
AOP builds on previously modularity techniques like procedures and object-oriented
programming. AOP goes beyond these techniques by supporting the modularization
of crosscutting concerns. AOP can make it possible to develop modular designs
and implementations of concerns like synchronization policies, business rules,
resource management, architecture enforcement, security rules, persistence layer
interaction, performance optimizations and many others.
By making code more modular, AOP makes software easier to design, develop, maintain,
evolve and deploy, and makes software and software designs more valuable.
This tutorial provides a deep introduction to AOP. We will cover the problems
AOP solves, conceptual underpinnings, mechanisms, how to read and write simple
aspects, how to "think aspects" at the design and code levels, tool
support, reusable aspects, aspect patterns, and an overview of strategies companies
have used to execute effective adoption of AOP. We will also discuss current
AOP research, and how that work relates to commercial use of the technology.
Presenters'
Biography:
Gregor Kiczales is
Professor of Computer Science at the University of British
Columbia.
His work is directed at enabling programmers to write programs that, as much
as possible, look like their design. He has pursued this goal in a number of
projects, including CLOS and its metaobject protocol, open implementations
of system software and middleware, and aspect-oriented programming. He led
the Xerox
PARC project that developed aspect-oriented programming and AspectJ. He is
author, with Danny Bobrow and Jim des Rivieres of "The Art of the Metaobject Protocol".
H12: What You always Wanted to Know about
Agile Methods But Did Not Dare to Ask
Frank Maurer, Grigori Melnik (University of Calgary, Canada)
17 May 2005 - Tuesday
- Afternoon
Director's Row #46 [Floor
Plan]
Abstract:
A fleet of emerging agile methods is both gaining popularity and generating lots
of controversy. Real-world examples argue for and against agile methods. This
high-level overview tutorial provides background to understand how agile teams
are trying to solve modern software development issues. A detailed comparison
of agile methods vs. Tayloristic methods is given. This is followed by an examination
of the main practices of individual methods (including eXtreme Programming, Scrum,
Agile Modeling, DSDM, Crystal, FDD, Lean Programming). In order to highlight
agile methods strengths and limitations, some empirical evidence is presented
and analyzed. Participants will discuss what is needed for agile methods to cross
the chasm from early adopters to the mainstream of software development. Among
other topics, the tutorial addresses the issues of knowledge sharing, project
management, and social implications of agile methods.
This tutorial is aimed at developers, managers, QA specialists, business customers
and academics who are new to agile methods and who would like to acquire basic
knowledge of underlying agile practices as well as to discuss - from a business
perspective - the benefits of and issues with applying agile approaches. No prior
experience with agile methods needed.
Presenters'
Biography:
Frank
Maurer is a Professor and an Associate
Head of the Department of Computer Science at the University of Calgary. His
research interests are agile software
methodologies, e-Business software engineering, Web engineering, globally distributed
software development, experience and knowledge management. He is a member of
Agile Alliance and a Certified Scrum Master. He is also a founding member of
The Canadian Agile Network - Le Réseau Agile Canadien and a founding member
of the board of the Calgary Agile Methods User Group. Frank Maurer was also involved
with the agile community as a Program Co-chair for XP Agile Universe 2003, and
a program committee member in 2002 and 2004. Dr Maurer was the program committee
member and/or program committee chair of various conferences and workshops in
the areas of software engineering, knowledge engineering, agile methods, and
distributed software development.
Grigori
Melnik is a researcher and an educator
with 11 years of academic and 6 years of industrial experience. He is currently
an Instructor at the
University of Calgary and a Lead Instructor at SAIT Polytechnic. Grigori
holds MSc in Applied Mathematics, MSc in Economics and is currently finishing
Ph.D. in Computer Science. His primary research area is empirical evaluation
of capabilities of agile methods. Other areas include e-business software
development, distributed software engineering, and distance education. Grigori
has been involved in several high-profile industrial projects (including
Microsoft Canada Money and Microsoft Canada SmallBiz portals). More recently
he has served as a founding co-moderator of Calgary Agile Methods User Group
and a coordinator of The Canadian Agile Network - Le Réseau Agile
Canadien. Grigori has been on the XP Agile Universe Program Committee since
2003. He is a Certified Scrum Master and a member of ACM, Agile Alliance,
CADE, IEEE, IEEE Computer Society, IFPUG, and SIAM.
