ISOTAS '96

Tutorials

Mar. 11, 1996

[T1] An In-Depth Look at Reusability (B. Meyer)

[T2] Obeject-Oriented Software Engineering (S. Honiden)

Mar. 12, 1996

[T3] Using Design Patterns: Elements of Reusable Architectures (R. Helm)

[T4] Open Implementation Analysis and Design [TM] (G. Kiczales, et al)

[T5] Efficient Implementation of Object-Oriented Programming Languages (C. Chambers)

*Reduced fees apply to JSSST, ACM, IEEE Computer Society, IEICE and IPSJ members.

Drawing on the experience of thousands of widely reused classes, this presentation will explain the issues, both managerial and technical, that must be addressed for a successful reuse policy. It will review what managers must do to promote reuse in their organization, and describe the technical tools that are necessary to produce large numbers of high-quality reusable components. The technical part of the presentation will be based on the Eiffel approach to reusability and reliability.

Among the topics surveyed:

• Real and imagined obstacles to reuse, and how to overcome them.
• Degrees of reusability.
• Producers and consumers. Where to concentrate efforts.
• Technical issues in reuse. What is the contribution of object technology?
• High-level design principles to ensure software reusability: active data structures, command-query separation principle, uniform access, options vs. parameters, etc.
• Using inheritance properly.
• A Linnaean approach to the cataloging of fundamental reusable structure.
• Design by Contract and its influence on library design and use.
• How to make a library easy to use.
• Style rules: choice of names, argument passing, class organization, feature clauses, comments.
• Metrics of reuse and quality. Measurements and statistics from existing libraries.
• Documenting reusable components.
• Library organization.
• The role of consistency.
• Lessons from successful reusable libraries.
• Specific needs of application libraries. The role of the application domain.
• The future of reusability.

Bertrand Meyer is president of ISE Inc. (Santa Barbara), editor of two book series (Prentice Hall's Object-Oriented Series and Addison-Wesley's ``Eiffel in Practice''), chairman of the TOOLS conferences (Technology of Object-Oriented Languages and Systems) and associate member of the applications section of the French Academy of Sciences. He is the author of many books including two available in Japanese (``Object-Oriented Software Construction'', ``Introduction to the Theory of Programming Languages''), ``Object Success'' (a presentation of object technology for managers), ``Eiffel: The Language'', and ``Reusable Software'' (on the tutorial's topics). He has directed successful projects of more than half a million lines of reusable object-oriented reusable software.

[NEXT][TOP]

The tutorial has two major parts. Part one focuses on object-oriented analysis and design method - the basic concept of methodology, the several methodology examples, an overview of state-of-the-art methodologies, and the applications to the practical system. It also discusses some success and failure stories that shed light on the lessons to be learned.

Part two focuses focuses on reusable software components, such as design pattern, framework, and componentware. It gives an overview of approaches and how to apply reusable software components in application domains.

Shinichi Honiden received the B.E., M.E., and Dr. Eng. degrees in electrical engineering from Waseda University, Tokyo, Japan, in 1976, 1978, and 1986, respectively. Since 1978, he has been with Toshiba Corporation, Tokyo. His research interests include software engineering and artificial intelligence, with particular reference to object-oriented analysis and design, agent-oriented model, formal specification languages and methodologies, and analysis and validation techniques for real-time and concurrent systems. He has published more than 70 papers in journals and international conferences of the fields, and 6 books on object-oriented software engineering.

[PREV] [NEXT] [TOP]

[PREV] [NEXT] [TOP]

Open Implementation Analysis and Design is a new methodology for designing Open Implementations of substrate software. The designer of any performance-critical reusable software faces a difficult challenge: there are many implementation decisions that will invariably bias the system's performance towards one kind of client use and away from others. For example: a file system implementation can be designed to penalize or favor the use of many small files; a virtual memory system can be designed to penalize or favor its use in implementing a database; a set abstraction can penalize or favor frequent delete operations etc. We call such decisions implementation strategy dilemmas, to reflect the fact that the designer seems forced to choose between making some clients happy vs making other clients happy. Open Implementation is an architectural solution to this problem that works by allowing clients of a module principled control over the module's implementation strategy decisions. So, for example, one client of a file system could choose the block size for their files and in doing so ensure that the file system was biased towards their needs. Open Implementation Analysis and Design is a methodology that allows designers to decide what aspects of a module's implementation a client should control, and how best to provide that control. This methodology is synergistic with OOA/D methodologies, but places more of an emphasis on how to make software that is tailorable by clients.

Gregor Kiczales is the leader of the Open Implementation project at Xerox PARC. He is the inventor of the concept of Open Implementation, and one of the developers of OIA/D. He has done extensive work in object-oriented programming languages and techniques, and in the area of metaobject protocols.

Chris Maeda is a member of the Open Implementation project at PARC. He is one of the developers of OIA/D.

Arthur Lee is a professor at Korea University, where he heads a new project on Open Implementation. He is one of the developers of OIA/D.

[PREV] [NEXT] [TOP]

How are object-oriented languages implemented? What features of object-oriented languages are expensive? What optimizations have been developed to make object-oriented languages more efficient? How important is compiler optimization for supporting high-level object-oriented languages? What are important considerations when assessing the effectiveness of compiler optimization? This tutorial aims to provide some answers to these questions. The tutorial will begin by presenting the important language design issues, identifying the features of object-oriented languages that are difficult to implement efficiently. In the main part of the tutorial, three classes of implementation techniques will be presented. First, run-time system techniques such as virtual function dispatch tables and inline caches will be described. Second, the tutorial will describe several levels of static analyses which seek to identify at compile-time the possible classes of message receivers in order to reduce or eliminate the overhead of dynamic binding. Third, the tutorial will discuss ways in which dynamic execution profiles can be exploited to complement static analysis techniques. The tutorial will present empirical measurements of the effectiveness of these various techniques for different kinds of programs and languages.

Craig Chambers has been researching object-oriented language design and implementation since 1987, with publications in OOPSLA, ECOOP, and PLDI on the topic. He developed the first efficient implementation of the Self language, and he is the designer of the Cecil language and heads the Vortex optimizing compiler project. Chambers is currently an Assistant Professor of Computer Science & Engineering at the University of Washington.

[PREV] [TOP]

• Tutorials [in Japanese]
• Back to ISOTAS '96 Home Page