This section summarizes the interesting challenges in the development of tailorable sys-tems.
System development typically comprises of many phases: e.g. requirementsanalysis, mod-eling, design, implementation, use. In building a tailorable system, one can focus on each of these phases to determine what new issues must be considered. For example, in the requirements-analysis phase, one typically captures the current requirements of the user.
In order to create the requirements for a tailorable system, however, it is also necessary to capture domains of anticipated changes in the system. If the system is to be used by a group of users, it is impossible for them all to be comfortable with the same set of requirements. It is inevitable that there will be dierences in how the system will be used by dierent users. These dierences must be captured as much as possible. In addition, foreseen organizational changes should be taken into account. In short, any circumstances which could aect the use of the system must be captured. Hence, instead of ending up
with requirements for a single system, one should end up with requirements for a range of systems. An interesting research problem is to try to formalize the analysis phase for a tailorable system. [Tri93] explores this line of thought in considerable detail.
The modeling phase can also be extended to handle tailorable systems. Here, the initial model, produced using conventional techniques, must go through a process of generaliza-tion. Instead of just modeling the specied system, the model should capture the problem domain in general. This process will lead to insights into which aspects of the system should be tailorable. Such a modeling exercise is described in [KN93]. Another interesting research problem would be to study the modeling phase for tailorable systems.
Analysis and modeling, however, haven't been the subject of this dissertation. Although they have been examined in some detail, there still remains much to be done in those areas. An experimental approach, in which these phases are conducted for a variety of real tailorable systems, is probably the best one to adopt.
The focus of this dissertation is primarily on the design, and implementation phases, with some discussions on the use phase. In the design phase, the model is transformed into an implementation architecture. A number of decisions are made during this phase. These inuence the tailorability of the resulting system. Taking the example of a hypermedia system, the model of the system may describe the structure of a media-type and the various operations on it. It doesn't say anything about how the implementation of a media-type should be organized. There are endless choices to be made. Tailorability concerns can constrain this set of choices. The hypermedia system presented in Chapter 6 implements a media-type in many dierent layers; this is primarily to make the system highly tailorable, as well as easily portable. This is one of the problems addressed by this dissertation.
In the implementation phase, the architecture must be realized in some programming language. The types of tailorability described by the requirements, the model, and the architecture, must be realizable in the chosen programming language. This dissertation examines language-level issues; it captures what exactly is needed, in terms of a language, in order to implement tailorable architectures.
Most dynamically-tailorable systems today are of two types: (1) developed in a dynamic language, with tailoring supported by the language and its environment,and (2) developed in a static language with tailoring supported by an embedded interpreter/compiler for some static or dynamic scripting language. Notecards [TMH87] is an example of (1).
Microsoft Excel [Mic93], ACE [JNZM93], Emacs [Sta84] are examples of (2). For reasons discussed in Chapter 2, and justied time and again, this dissertation deals with systems of type (2). However, instead of using the approach in which a scripting language, dierent from the original development language, is used, it chooses to use the original language
as the scripting language. This, in addition to being potentially more powerful than some ad hoc scripting language, also allows direct access to the internals of the original system.
In addition, as is shown in the thesis, it makes it next to trivial to introduce dynamic tailorability into a system which is designed to be tailorable.
This does, however, create new problems to be dealt with. Since the original development language is a static one, a scheme must be devised for handling dynamic extensions. In fact, the language chosen by the dissertation is the statically-compiled, object-oriented, block-structured, strongly- and statically-typed language Beta [MMPN93]; Chapter 2 motivates this choice of language in great detail. In order for a system to accept Beta as the \scripting" language, it must be able to compile or interpret Beta code in its own context. The problem then is to build stand-alone systems, written in Beta, which can accept extensions, written in Beta, at run-time. The problem is made more dicult because of the fact that Beta is very static in nature.
Beta applications often use a persistent store or an object-oriented database (OODB) to store object instances. In general the classes describing these object instances are compiled into the application saving or loading the objects. Once the application is extensible, new classes, and hence new object instances, which are not compiled into the application, can exist at run-time. A problem arises when these object instances are saved into the persistent store or OODB, for, if later, they are loaded by an application which has not been extended appropriately, the results will be unexpected.
The use phase is when the user tailors the system. There are many problems that can be examined here. The most interesting ones deals with comprehension of the system in order to tailor it. This is not dealt with directly in this dissertation. Other researchers are working on this area (see Section 1.6). This dissertation does illustrate the type of eort required of the user in order to tailor a hypermedia system. Also addressed is the issue of building domain-specic tailoring tools in order to simplify the task of the tailoring user.
Today, a number of tailorable systems exist. Some of these applications oer shallow tailoring (e.g. Microsoft Excel), where macros can be built, or the user-interface can be reorganized. Others oer deep tailoring (e.g. Emacs [Sta84], Notecards [TMH87]), where signicant changes to the original functionality can be made. There are, however, only a few published systematic approaches to building tailorable systems. In the reection community, there is work on building meta-level architectures ([KdRB91, CM93]); the focus of this work is however the domain of programming languages and their implemen-tation, although [CM93] uses reection in order to implement distribution. The problem of presenting a systematic approach for building a tailorable system is addressed by this dissertation: it describes an approach for building tailorable hypermedia systems.