Adaptive Programming (AP) is a programming technique that has grown out of the need to write programs that are more flexible [13]. The Law of Demeter (LoD) [new 15] and a specialization, the Law of Demeter for Concerns (LoDC) [14] have been proposed as style rules that promote flexibility. The Law of Demeter for concerns is a style rule for programming that says: Talk only to your friends that share your current concerns. In the context of an object-oriented system, the friends of a method are the 1 2 Chapter 6 Coupling Aspect-Oriented and Adaptive Programming preferred supplier objects: the argument objects, including this, the immediate parts of this and newly created objects in the method. A concern is any issue the designer is concerned with, such as a use case or the synchronization or logging policy for the system. The Law of Demeter is the first part of LoDC: Talk only to your friends, i.e., each method should only send messages to preferred supplier objects. LoD implies LoD. Following

SmartTools is a development environment generator that provides a structure editor and semantic tools as main features. The well-known visitor pattern technique is commonly used for designing semantic analysis, it has been automated and extended. SmartTools is easy to use thanks to its graphical user interface designed with the Java Swing APIs. It is built with an open architecture convenient for a partial or total integration of SmartTools in other environments. It makes the addition of new software components in SmartTools easy. As a result of the modular architecture, we built a distributed instance of SmartTools which required minimal eoeort. Being open to the XML technologies ooeers all the features of SmartTools to any language defined with those technologies. But most of all, with its open architecture, SmartTools takes advantage of all the developments made around those technologies, like DOM, through the XML APIs. The fast development of SmartTools (which is a young project, one year old) validates our choices of being open and generic.The main goal of this tool is to provide help and support for designing software development environments for programming languages as well as application languages dened with XML technologies.

Computer (IEEE), 2006. Abstract: In software design, laziness is a virtue: it’s better to reuse than to redo. Design patterns are a good illustration. Patterns, a major advance in software architecture, provide a common vocabulary and a widely known catalog of design solutions addressing frequently encountered situations. But they do not support reuse, which assumes components: off-the-shelf modules ready to be integrated into an application through the sole knowledge of a program interface (API). Is it possible to go beyond patterns by componentizing them — turning them into components? We have built a component library which answers this question positively for a large subset of the bestknown design patterns. Here we summarize these results and analyze the componentization process through the example of an important pattern, Visitor, showing how to take advantage of object-oriented language mechanisms to replace the design work of using a pattern by mere “ready-to-wear ” reuse through an API. The reusable solution is not only easier to use but more general than the pattern, removing its known limitations; performance analysis on a large industrial application shows that the approach is realistic and scales up gracefully.

Web Service orchestration engines need to be more open to enable the addition of new behaviours into service-based applications. In this paper, we illustrate how, in a BPEL engine with aspect-weaving capabilities, a process-driven application based on the Google Web Service can be dynamically adapted with new behaviours and hot-fixed to meet unforeseen postdeployment requirements. Business processes (the application skeletons) can be enriched with additional features such as debugging, execution monitoring, or an application-specific GUI. Dynamic aspects are also used on the processes themselves to tackle the problem of hot-fixes to long running processes. In this manner, composing a Web Service ’on-the-fly ’ means weaving its choreography interface into the business process. 1.

Abstract not found

Domain specific languages (DSLs) are increasingly used today. Coping with complex language definitions, evolving them in a structured way, and ensuring their error freeness are the main challenges of DSL design and implementation. The use of modular language definitions and composition operators are therefore inevitable in the independent development of language components. In this article, we discuss these arising issues by describing a framework for the compositional development of textual DSLs and their supporting tools. We use a redundance-free definition of a readable concrete syntax and a comprehensible abstract syntax as both representations significantly overlap in their structure. For enhancing the usability of the abstract syntax, we added concepts like associations and inheritance to a grammarbased definition in order to build up arbitrary graphs (as known from metamodeling). Two modularity concepts, grammar inheritance and embedding, are discussed. They permit compositional language definition and thus simplify the extension of languages based on already existing ones. We demonstrate that compositional engineering of new languages is a useful concept when project-individual DSLs with appropriate tool support are defined.

SmartTools is a semantic framework generator, based on XML and object technologies. Thanks to a process of automatic generation from specifications, SmartTools makes it possible to quickly develop environments dedicated to domain-specific and programming languages. Some of these specifications (XML, DTD, Schemas, XSLT) are issued from the W3C which is an important source of varied emerging domain-specific languages. Smart-Tools uses object technologies such as visitor patterns and aspect-oriented programming. It provides code generation adapted to the usage of those technologies to support the development of semantic analyses. In this way, we obtain at minimal cost the design and implementation of a modular development platform which is open, interactive, uniform, and most important prone to evolution.

. The growing application of theorem proving techniques has increased the need for customized theorem provers. Powerful provers contain numerous interacting subsystems, each of which requires substantial time and expertise to build; constructing new provers from scratch is virtually prohibitive. Plug-and-play prover frameworks promise an alternative in which developers can construct provers by selecting logics, reasoning techniques, and interfaces. Realizing such frameworks cleanly requires specialized software architectures and particular language abstractions, even for frameworks supporting only simple interactions between logics. This paper explores architectural and linguistic issues in plug-and-play theorem prover development. It reflects our experience creating and using such a framework to develop several versions of a research prototype theorem prover. Keywords: extensible theorem provers, plug-and-play theorem provers, software architectures, software components, programming ...

Recursive types denitions and pattern-matching are two useful built-in features of functional languages. No such mechanism is present in the Java language. In this article, we investigate dierent implementations to support these features in Java. First, we review ways to dene recursive types. Then, we expose several approaches allowing to simulate pattern-matching on structures of these types. Finally, we present re-use techniques for algorithms featuring this mechanism.

Type-directed programming is an important and widely used paradigm in the design of software. With this form of programming, a program may analyze type information to determine its behavior. By analyzing the structure of data, many operations, such as serialization, cloning, structural equality, and iterators, may be defined once, for all types of data. The benefit of type-directed programming is that as software evolves, operations need not be updated---they will automatically adapt to new data forms. Otherwise, each of these operations must be individually redefined for each type of data, forcing programmers to revisit the same program logic many times during a program's lifetime.