Back to main program page

The ICSE 2004 program includes fifteen tutorials, covering a wide range of important topics from research and practice. Tutorials will be held on Monday 24th and Tuesday 25th May, and will be either half a day or a full day in length.

Formal Concept Analysis in Software Engineering

Monday 24th May 2004 - half day (09:30 - 12:30) - EICC – Carrick 2
Presenter: Paolo Tonella, ITC-IRST
Email: tonella@itc.it

Concept analysis is a very general method to analyze a binary relationship between arbitrary objects and attributes. Its output is a lattice of so-called concepts, which offers non trivial insights into the structure underlying the original relationship. Each lattice node (concept) contains maximal sets of objects sharing common attributes. The hierarchy of concepts in the lattice can be interpreted as the possibility to generalize or specialize a concept.

In the analysis of software systems, several relationships among the composing entities emerge. For this reason, concept analysis found a very productive application area in software engineering. Static and dynamic relationships among software components can be subjected to concept analysis to obtain information useful during maintenance, for program comprehension, and in the execution of reengineering tasks.

The objective of this tutorial is to provide background and methodological knowledge on concept analysis and on its usage in software engineering. This will be achieved by describing three recent, representative applications of concept analysis in detail. They concern respectively the reorganization of a legacy system into cohesive units, the inference of design patterns without any a-priori information, and the decomposition of a software system into computational units (decomposition slices), that may be strongly dependent, weakly dependent or independent with each other. Other examples of applications, presented more succinctly, include the reengineering of class hierarchies, feature location by means of dynamic analysis, and the derivation of a software configuration structure.

Participants in this tutorial will acquire a basic background and methodological knowledge on concept analysis and on its usage in software engineering. They will learn how to use concept analysis to tackle problems such as code restructuring, design pattern recovery and impact analysis. Moreover, they will learn the core competencies necessary to generalize the approach, in order to use it in a new context.

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 full time researcher of the Software Engineering group at ITC-irst, Trento, Italy. He participated in several industrial and European Community projects on software analysis and testing. At the University of Trento, Paolo Tonella teaches the course "Software Analysis and Testing" for undergraduate and PhD students.

Paolo Tonella has published over 17 journal papers, 2 book chapters, and 28 conference papers. He is in the Organizing Committees of events such as SCAM (Source Code Analysis and Manipulation), WSE (Web Site Evolution), and IWPC (International Workshop on Program Comprehension). He has edited a special issue of the Journal of Software Maintenance and Evolution on Web Site Evolution and he is editing a special issue of the Software Quality Journal. He regularly reviews papers for journals such as the IEEE Transactions on Software Engineering and the Journal of Software Maintenance and Evolution. In 2004, Springer-Verlag will publish a book by P. Tonella and A. Potrich entitled "Reverse Engineering of Object Oriented Code".

An Overview of UML 2.0

Tuesday 25th May 2004 - half day (09:30 - 12:30) - Sheraton - 2
Presenter: Bran Selic, IBM Rational Software and Carleton University,

Since its adoption as an industry standard in 1997, the Unified Modeling Language (UML) has been adopted widely by both industry and academia. This extensive experience has naturally led to demands for improvements and new capabilities. In September 2000, the Object Management Group-the industrial consortium that controls the UML standard-issued a request for proposal for the first major revision of UML, UML 2.0. This new version was conceived as the basis for the coming generation of model-based development methods, such as OMG's Model-Driven Architecture (MDA). The distinguishing characteristic of these methods is that their primary focus is on the definition and evolution of models rather than programs-with programs being automatically generated from such models. The combination of higher-level abstractions defined in UML and the use of automation provide the potential for a dramatic improvement in productivity and software reliability.

Attendees of this half-day tutorial will learn the salient aspects of UML 2.0-from the perspective of one of its primary authors. The following specific topics will be covered: a general and critical discussion of the effectiveness of modeling techniques in software engineering; a critical review of the original UML standard based on the lessons learned from its application as well as from theoretical studies; the formal and informal requirements that drove development of the new version of UML (this includes an introduction to model-driven development methods); the overall structure and design philosophy behind UML 2.0; the conceptual foundation, or "infrastructure" used to define the UML modeling concepts and their semantics; new modeling capabilities for rendering software structures such as those required for specifying software architectures; new modeling capabilities for describing complex behavior of individual objects and groups of collaborating objects; changes to existing UML concepts.

Bran Selic is a Distinguished Engineer at IBM Rational Software in Kanata, Canada and an Adjunct Professor of Computer Science at Carleton University in Ottawa. He has over three decades of industrial experience in the design and evelopment of complex software systems in a variety of different domains. He is the primary author of one of the earliest technical textbooks (published in 1994) that describes practical model-driven software development techniques. Bran has been involved with the definition and standardization of the UML language from 1996 and is currently chairing the task force responsible for standardizing the UML 2.0 revision. He has published widely and has given numerous invited talks on model-driven development and related topics.

Software Variability Management

Monday 24th May 2004 - half day (14:00 - 17:00)- EICC – Carrick 2
Presenter: Jan Bosch, University of Groningen
Email: Jan.Bosch@cs.rug.nl

In a variety of approaches to software development, software artifacts are used in multiple contexts or for various purposes. The differences lead to so-called variation points in the software artifact. During recent years, the amount of variability supported by a software artifact is growing considerably and its management is developing as a main challenge in the development, usage and evolution of software artifacts. Examples of approaches where the management of variability is evolving as a challenge include software product families, component-based software development, object-oriented frameworks and configurable software products such as enterprise resource planning systems.

The tutorial presents insights gained, techniques developed and lessons learned in the European IST project ConIPF (Configuration in Industrial Product Families) and in other research performed by the software engineering research group at the University of Groningen. The tutorial first establishes the importance of software variability management, defines the concept of variability, discusses notational and visualization aspects, assessment of software artifacts for variability, design of architectures and components for variability, usage of variation points while configuring instantiated software artefacts and, finally, some advanced issues including variation versus composition.

Dr. Jan Bosch is a professor of software engineering at the University of Groningen, The Netherlands, where he heads the software engineering research group. He received a MSc degree from the University of Twente, The Netherlands, and a PhD degree from Lund University, Sweden. His research activities include software architecture design, software product families, software variability management and component-oriented programming. He is the author of a book "Design and Use of Software Architectures: Adopting and Evolving a Product Line Approach" published by Pearson Education (Addison-Wesley & ACM Press) and (co-)editor of three volumes in the Springer LNCS series. He has organised numerous workshops, served on many programme committees, including the ICSR'6, CSMR'2000, ECBS'2000, GCSE, SPLC and TOOLS conferences and is member of the steering groups of the GCSE and WICSA conferences. He was the PC co-chair of the 3rd IFIP (IEEE) Working Conference on Software Architecture (WICSA-3), is the general chair for WICSA-4 and PC co-chair for the 8th International Conference on Software Reuse (ICSR-8).

Software Architecture Reconstruction

Monday 24th May 2004 - full day (09:30 – 17:30) - EICC – Ochil 3
Presenters Claudio Riva, Nokia Research Center
Email: claudio.riva@nokia.com

Nowadays, practitioners well recognize the importance of describing the software architecture as a key enabler for a successful and long living software system. The description of the software architecture should document the essential design decisions that the designers and programmers made in the past to fulfill the requirements of the system. However, keeping the description update or recovering it from an existing system are not simple tasks. Often it happens that there is a considerable gap between the actual implementation and the mental models of the designers. Answering basic questions becomes a challenge: who is the owner of a particular component ? What are the logical dependencies of a certain part of the system ? What types of components are used in the system ?

Architecture reconstruction is the reverse engineering activity that aims at recovering high-level abstract views of a software system from the existing assets. The reconstruction is performed by examining the available artifacts (documentation, source code, experts), simulating the system behavior with dynamic analysis techniques and inferring new architectural information that is not immediately evident.

This tutorial covers software architecture reconstruction. It addresses, amongst others, the following questions: How do we identify architecturally significant information? How can we extract, analyze and present it? What are the critical issues that have to be considered? How do we manage the reconstruction process in a product family? What tools and methods are available? This tutorial will address these and other questions that are relevant for the development of large and complex software systems.

Claudio Riva is a Senior Research Engineer at the Nokia Research Center in Helsinki, Finland, where his responsibilities include consulting the Nokia business units on the assessment, maintenance and evolution of their software architectures and product families. He has managed several reconstruction projects whose goal was to recover the architectures of large Nokia's systems. He has also been involved in international research projects on the topic. His research interests include architecture reconstruction, reverse engineering, software product lines, software visualization and scripting languages. He has published a range of articles in the areas of reverse engineering and software architecture, he is participating in the European project FAMILES in the area of product lines and he is the program chair of the eighth European Conference on Software Maintenance and Reverse Engineering (CSRM 2004). He graduated at the Politecnico of Milano in Telecommunication Engineering and he is carrying out his Ph.D. on architecture reconstruction at the Vienna University of Technology.

Software Modeling Techniques and the Semantic Web

Tuesday 25th May 2004 - full Day (09:30 – 17:30) - The Point - Five
Presenter: Jin Song Dong, National University of Singapore
Email: dongjs@comp.nus.edu.sg

Following the success of XML, W3C envisions the Semantic Web (SW) as the next generation of web in which data are given well-defined and machine-understandable semantics so that they can be processed by intelligent software agents. SW can be regarded as an emerging area from the Knowledge Representation and the Web Communities. The Software Engineering community can also play an important role in the SW development. Modeling and verification techniques can be useful at many stages during the design, maintenance and deployment of SW ontology. We believe SW will be a new research and application domain for software modeling techniques and tools. For example, recent research results have shown that UML, Z and Alloy can provide modeling, reasoning and consistency checking services for SW.

On the other hand, the diversity of various software specification techniques and the need for their effective combinations requires an extensible and integrated supporting environment. The success of the Semantic Web may have profound impact on the web environment for software design methods, especially for extending and integrating different software modeling techniques.

This full-day tutorial (with no specific prerequisite) is aimed at both industrial and academic participants. The tutorial will include:

  • A detailed introduction to Semantic Web languages (DAML+OIL and OWL) and Semantic Web tools (FaCT and RACER).
  • An introduction to software modeling techniques Z, Alloy and UML and a demonstration on how they can facilitate modeling, checking and reasoning about web ontologies.
  • A military plan ontology case study where we discovered a number of errors in the original ontologies with the help of the combination of RACER, Alloy Analyser and Z/EVES tools.
  • An illustration on how DAML+OIL can be used to build a Semantic Web environment for supporting, extending and integrating various software specification languages.

Dr. Jin Song Dong received Bachelor (1st Class Honors) and PhD degrees in computing from the University of Queensland (UQ) in 1992 and 1996. He was the winner of the Richard Jago Memorial Prize and Australian Postgraduate Award. From 1995-1998, he was a Research Scientist at the Commonwealth Scientific and Industrial Research Organisation (CSIRO) in Australia. Since 1998, he has been a faculty member at the National University of Singapore (NUS). He has about 50 international refereed publications in areas of formal methods, web-based software design and semantics of programming languages. Jin Song is a steering committee member of the International Conference on Formal Engineering Methods (ICFEM) and the Asia Pacific Software engineering Conference (APSEC). He is a Program Co-Chair for the 5th ICFEM (2003) and the 7th APSEC (2000), and a program committee member for a number of international conferences on formal methods and software engineering. He has been a Principal Investigator of various research projects funded by Singapore National Science Technology Board and Defence Science Technology Agency. Jin Song has been a tutorial presenter at ICSE'01 and FME'03.

Usability Supporting Architectural Patterns

Tuesday 25th May 2004 - full day (09:30 – 17:30) - The Point - Three
Presenters: Len Bass (lead presenter), Software Engineering Institute, CMU; Bonnie E. John, Human Computer Interaction Institute, CMU; Natalia Juristo, Universidad Politecnica de Madrid; Maribel Sanchez-Segura, Carlos III University of Madrid
Email: misanche@inf.uc3m.es

Software architects have techniques to deal with many quality attributes such as performance, reliability, and maintainability. Usability, however, has traditionally been concerned primarily with presentation and not been a concern of software architects beyond separating the user interface from the remainder of the application.

A usability-supporting architectural patterns (USAP) describes a usability concern that is not supported by separation alone. For each concern, a USAP provides the forces from the characteristics of the task and environment, the human, and the state of the software to motivate an implementation independent solution cast in terms of the responsibilities that must be fulfilled to satisfy the forces. Furthermore, each pattern includes a sample solution implemented in the context of an overriding separation based pattern such as J2EE Model View Controller.

During the tutorial, the instructors will present the concept of a USAP and several examples. The instructors will also facilitate an exercise where attendees will develop their own USAP.

Len Bass is the author of two award winning books in software architecture. He has broad industrial experience in the design and evaluation of software architectures.

Bonnie John is an engineer who has worked both in industry and academe. She is an Associate Professor in the Human-Computer Interaction Institute and the Director of the Masters Program in HCI.

Natalia Juristo is a professor of Software Engineering at the Computer Science School of Universidad Politecnica de Madrid. She is director of the MSc in Software Engineering. Dr. Juristo is widely published in software engineering and has been a member of several editorial boards.

Maribel Sanchez-Segura is on the faculty of Computer Science Department at Carlos III University of Madrid. She has performed research into the relationship between usability and software engineering.

Testing Object Oriented Software

Tuesday 25th May 2004 - full day (09:30 – 17:30) - Sheraton - 1
Presenters: Mauro Pezze, University of Milan Bicocca; Michal Young, University of Oregon
Email: pezze@disco.unimib.it; michal@cs.uoregon.edu

Object-oriented software requires reconsidering and adapting approaches to software test and analysis. Some traditional test and analysis techniques are easily adjusted to object-oriented software, but others require substantial revision, and yet others need to be introduced to cope with new problems of object-oriented software.

This tutorial brings together process and technical aspects of testing object-oriented software in an overall coherent framework that considers what can be simply adapted from conventional test practices and what new and extended techniques are required. Topics include test planning, test design from specification and design documentation, adapting design and code inspection to object oriented software development, intra- and inter-class structural testing, testing programs with exception-handling and threading, test oracles for object-oriented programs, regression testing, and process improvement.

Attendees will gain an understanding of challenges in testing in object-oriented software and several techniques that have been devised for dealing with them. They will learn how to formulate a systematic approach to testing object-oriented software, considering both process and technical issues.

This tutorial is designed for practitioners who may have some experience with object oriented design and quality assurance, but who desire a broader view of testing and analysis of object oriented software. It is also suitable for teachers, students, and researchers in software engineering who desire a coherent overview of problems and techniques for analysis and test of object oriented software.

A general knowledge of software engineering and some familiarity with software development practice will be assumed. Experience with one or more software quality assurance techniques will be helpful but not essential.

Michal Young is associate professor and head of the Computer and Information Science Department at the University of Oregon. He received a BA degree (summa cum laude) in computer and information science from University of Oregon in 1983, and MS and Ph.D. degrees in information and computer science from University of California, Irvine in 1985 and 1989. Dr. Young's primary research interests are analysis and testing of concurrent software systems. He has served as program chair for the 1998 ACM/Sigsoft International Symposium on Software Testing and Analysis, as program co-chair for the 2002 International Conference on Software Engineering, and on numerous program committees for major software engineering conferences.

Dr. Young's papers have appeared in ACM Transactions on Software Engineering and Methodology, IEEE Transactions on Software Engineering, and the Journal of Software Testing, Verification.

Mauro Pezze` is professor of computer science at the University of Milan Bicocca since 2000. Prior to that, he was on the faculty of Politecnico of Milan. He received his degree in Computer Science (summa cum laude) from the University of Pisa and the PhD in Computer Engineering from Politecnico of Milan. Dr. Pezze's research interests include system and software engineering; software engineering environments; specification, analysis, testing and validation of concurrent, real-time and object-oriented systems; and legacy and hybrid systems. He serves on the Steering Committee of the European Joint conferences on Theory and Practice of Software (ETAPS). He was general chair of ICECCS'97, chair of FASE 2003 and TACoS 2003, program co-chair of ICECCS'96 and GT-VMT '01. His publications have appeared in ACM Transactions on Software Engineering and Methodology, IEEE Transactions on Software Engineering, IEEE Transactions on Control Systems Technology, the Journal of Real-Time Systems, the Journal of High-Integrity Systems, and Programming Languages.

Case Studies for Software Engineers

Monday 24th May 2004 - full day (09:30 – 17:30) - EICC – Carrick 1
Presenters: Dewayne E Perry; Susan Eliliot Sim and Steve Easterbrook

The purpose of this full-day tutorial is to delineate and illustrate the correct use and interpretation of case studies. It will help software engineers identify and avoid common mistakes by giving them a solid grounding in the fundamentals of case studies as a research method. Using an equal blend of lecture and discussion, it aims to provide software engineers with a foundation for conducting, reviewing, and reading case studies. For researchers, this tutorial will provide a starting point for learning how to conduct case studies. They will be able to find, assess, and apply appropriate resources at their home institution. For reviewers, the tutorial will provide guidance on how to judge the quality and validity of reported case studies. They will be able to use the criteria presented in this tutorial to assess whether research papers based on case studies are suitable for publication, allowing them to raise the quality of publications and give appropriate feedback to authors. For practitioners, the tutorial will provide a better awareness of how to interpret the claims made by researchers about new software engineering methods and tools. Practitioners will also gain deeper insights into the roles they can play in designing and conducting case studies in collaborative research projects. As well, they will read case studies more effectively and be better able to identify results suitable for use in their workplace.

Dewayne E. Perry is a Professor and the Motorola Regents Chair of Software Engineering at The University of Texas at Austin. Susan Elliott Sim is an Assistant Professor at University of California, Irvine. Steve Easterbrook is an Associate Professor at University of Toronto. All three tutors have extensive experience in software engineering case studies.

Balancing Agility and Discipline: Evaluating and Integrating Agile and Plan-Driven Methods

Tuesday 25th May 2004 - full day (09:30 – 17:30) - EICC – Carrick 1
Presenters: Prof. Barry Boehm, USC; Prof. Richard Turner, George Washington U. and Dept. of Defense
Email: boehm@usc.edu; rich.turner.CTR@osd.mil

Rapid change and increasing software criticality are driving successful development and acquisition organizations to balance the agility and discipline of their key processes. The emergence of agile methods in the software community is raising the expectations of customers and management, but the methods have shortfalls and their compatibility with traditional plan-driven methods such as those represented by CMMI, ISO-15288, and UK-DefStan-00-55 is largely unexplored. Multiple sources of perplexity -- inconsistent definitions and interpretations, overgeneralization of successes and failures, confusing of methods' usage and misuse -- complicate the search for clarity of understanding.

This tutorial pragmatically examines the aspects of agile and plan-driven methods through examples and case studies. We characterize "home grounds" where the approaches are most likely to succeed, identifying five critical dimensions that describe the agile/plan-driven spectrum. We present a risk-based method for developing balanced strategies that take advantage of the strengths and mitigate the weaknesses of both agile and plan-driven approaches, and that fit the objectives, constraints, and priorities of a particular project or organization. Step-by-step walkthroughs of several example projects show how the method is applied. Finally, we involve participants in an exercise involving hands-on evaluation of their current organizational balance of agility and discipline, identification of their likely directions of change, and development of strategies for evolving their balance of agility and discipline to meet their future objectives and challenges.

Barry Boehm is the Director of the 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, and his 1981 book, "Software Engineering Economics." He and Dr. Turner have recently published the book "Balancing Agility and Discipline: A Guide for the Perplexed," Addison-Wesley, 2004.

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 is responsible for identifying and transitioning new software technology into software-intensive defense systems. He is a co-author of "CMMI(r) Distilled" and of "Balancing Agility and Discipline: A Guide for the Perplexed," Addison-Wesley, 2004.


Sails at front of the EICC New Town Facade EICC Fintry Auditorium The EICC Edinburgh at dusk

Back to main program page