JP2011170884A - Method and device for weaving aspect to changing base system - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To process a dynamic change within a base system in which one or more aspects are woven in an aspect oriented programming environment. <P>SOLUTION: The method for adapting to changes in the base system in an aspect oriented programming environment including an aspect system for implementing aspects to be woven into the base system using a weaver, includes: steps of, in response to a change in the base system, evaluating the importance of the change in the base system; and if the evaluation of the system change is found to be important, taking an adaptive action to compensate for the change. <P>COPYRIGHT: (C)2011,JPO&INPIT

Description

  The present invention relates to aspect-oriented programming (AOP), and more particularly to a method and apparatus for weaving aspects to a changing base system.

The present invention relates to the field of aspect-oriented programming (AOP). AOP uses a new modular structure called “aspect”.
Aspect provides elements that cross-cut the main modularization of software systems. An aspect-oriented programming language or system extends traditional programming languages and systems with elements of the programming aspect of the system. Such an element can localize the execution of the cross-cuts for the parts associated with a few special program modules and not for the entire main program module.

  To capture the cross-cut nature of the aspect, this special program module changes the traditional rules for encapsulation in a routine way. These special program modules can affect the execution of the main module without the explicit consent of the main module. Furthermore, they can affect several major modules simultaneously.

  Aspect-oriented programming (AOP) extends the expressive capabilities available to programs so that many design decisions can be expressed locally. An AOP programmer describes a basic program in a conventional programming language and further describes a part of an aspect code. Each of them affects the execution described in a part of the base program.

  In this way, aspect code is capable of implementing several design elements in several modules and does not extend the fields and methods of these patterns across classes. Then, for example, incorporating tracing, debugging and built-in support for complex systems in several modules, incorporating error handling protocols including several classes within a single module, and involving multiple classes throughout Rather than as part of the code, resources that share an algorithm containing several classes within a single module can be obtained.

  Special program modules for programming aspects make this possible by reasonably cross-cutting modules of more traditional modular constructs such as classes. Thus, one of these special program modules may affect the execution of several classes (or several methods within a single class) in a manner that follows a clean convention. Aspect-object interactions differ from object-to-object interactions and other traditional programming examples. The difference is that in the traditional scheme all object actions are performed directly within the object class definition, or other object actions (eg method invocations) to use the object class definition. Encapsulated in the object itself, either as a request encoded in it, or as a request in the definition of an object class to reuse (eg, inherit) the execution of other object classes That's what it means. For this reason, in these conventional methods, all control of the object motion depends on the object itself. On the other hand, in an AOP environment, part of an object action can be defined in an aspect outside the object, without the object requiring any action. Therefore, it can be said that part of the object motion is forced transparently with respect to the object by the aspect. Furthermore, an aspect has a more global effect in that one aspect can possibly force its action on multiple objects of different classes.

  Aspect-oriented programming (AOP) is introduced in Non-Patent Document 1. AOP handles portions of code that logically belong to a problem, but cannot be modularized because of the limited organization of the underlying programming language and environment. The resulting code is extremely complex and messy. The problem that causes such complication is called a crosscutting problem. Aspect orientation is about modularizing the crosscut problem into different modules called aspects.

  The mechanism for integrating the aspect module with the application is called weaving. The weaver is responsible for adding all aspects to the application. In order to define such integration, aspect orientation uses a concept called a join point. In Kickzales et al. (Non-Patent Document 1), join points are introduced as rational points in program execution. A typical example of a join point is a method call.

  Conventionally, the weaving process is initiated by a developer for a plurality of aspects that are to be integrated at a given point in time. Furthermore, the weaving process determines and adapts to all locations in the base system that represent join points that need to execute aspect-specific code potentially or reliably at runtime. The adapted position that represents the join point during runtime is called the join point shadow. Adapting to a certain join point shadow means that a certain correction is performed. This modification allows the advice code to be called or executed when the join point shadow is reached. This can be done by inserting a code that is actually executed at this location (“advice code”) or by using a “wrapper”. This wrapper operates a wrapped method to consider or execute the “advice” given by the aspect. This “adaptation” of the join point to the join point shadow is done by the weaving process.

  The aspect itself consists of a combination of advice code to be executed and a series of join point descriptions. This join point description represents a join point in the base system (a system without an aspect) as a point in the base system where the advice code is to be executed. A series of join point descriptions is called a “point cut”. Next, the weaving process, which can be regarded as a special editing process, modifies the base system so that execution of the advice code is possible once it reaches the associated join point. This is sometimes referred to as weaving the aspect to the base system, “installing aspects”, or “installing advice”. The location where weaver can execute aspect-specific code at runtime is called a joinpoint shadow. By weaving the aspect to the base system, the weaving process allows the advice code to be called in the join point shadow.

  Conventionally, the weaving process does not consider the possibility that the base system to which the aspect is to be weaved will change. In a traditional approach to weaving, a series of join point shadows associated with a weaved aspect is determined once at a certain time with some configuration of the base system (time to weave the aspect), and then the duration of the aspect and base system Survives for the same amount of time. This means that after weaving, all shadows in the application that can execute code specific to the aspect will be taken into account by the aspect into the base system without taking into account any changes in the base system. It means being adapted to a base system with a specific configuration when weaving.

Kiczales, G .; Lamping, J .; Mendhekar, A .; Maeda, C .; Loopes, C .; Loingtier, J .; -M. Irwing, J .; "Aspect-Oriented Programming", Proceedings of European Conference on Object-Oriented Programming (ECOOP), LNCS 1241, Springer-Verlag, 1996, p. 220-242

  Accordingly, it is an object of the present invention to provide a method and apparatus suitable for an aspect-oriented programming environment and capable of handling dynamic changes in a base system in which one or more aspects are weaved. is there.

  According to one embodiment of the present invention, a method for adapting to changes in a base system in an aspect-oriented programming environment that includes an aspect system that implements an aspect to be weaved into the base system using a weaver. Provided. The method includes evaluating the importance of the change in the base system in response to changes in the base system, and if the evaluation for the change is found to be important, the change is determined. Performing an adaptive operation to compensate.

  By evaluating system changes and, if necessary, performing adaptive operations on aspect configuration systems, the underlying base system can flexibly deal with any changes in the base system. Thus, changes in the base system (element changes, additions or removals) can be compensated so as to compensate and resolve mismatches between the aspect and base system resulting from changes in the base system.

  According to one embodiment, the assessment of importance is based on whether the join points before the changes in the base system or the join point shadow are different from those after the changes in the base system. A step of determining after a change in the system is included. This allows join points or join point shadows in the configuration system resulting from aspects weaved to the base system before the system changes to differ from those resulting from the weaving process performed on the modified base system. Can be determined after a change in the base system. This can be done, for example, by comparing aspect cuts before and after system changes and pointcuts for advice, and if they are different, the changes prove significant. This comparison can be done by directly comparing pointcuts or a series of joinpoints or joinpoint shadows before and after the system change. According to one embodiment, the two series can be done by simply comparing their number of elements, and if the numbers are different, it can be determined that there are significant changes. According to another embodiment, the comparison can be made by comparing a series of elements individually, i.e. by comparing all join points or join point shadows before the system change with those after the system change, If this individual comparison is found to be different, it can be determined that a significant change has occurred in the base system.

  According to one embodiment, the aspect-oriented programming environment includes an adaptive system in addition to the base system and the aspect system. Here, the adaptive system, the base system, and the aspect system are separate entities, and can be modified and executed independently of each other. As a result, the aspect system can be given great flexibility in addition to the adaptive system, so that the entire system can be designed more flexibly as well.

  According to one embodiment, the base system, the aspect system and the adaptive system interact with each other through direct or indirect calls such as function calls, method calls, sending messages, etc. This makes these three parts of the entire system independent of each other.

  According to one embodiment, the adaptive action includes the following: an action that reweaves the aspect into the base system in whole or in part, and advice that is associated with the aspect in whole or in part. One or more operations are included in the operation of re-weaving, the operation of unweaving the aspect in whole or in part, or the operation of unweaving the advice associated with the aspect in whole or in part.

  A method according to an embodiment of the invention includes the step of notifying a change in the base system to elements of the overall system, including the base system and aspects, when a change occurs in the base system, the element The following steps: starting a base system change evaluation; evaluating a base system change; starting an adaptive action based on the evaluation; and an adaptive action based on the evaluation One or more steps can be performed.

  Notifying system elements ensures that proper operation is performed after evaluating system changes. The notified system element may be an element separated from the base system, aspect, and advice. It can be entrusted to receive notifications about changes in the system and then start evaluating this change. Elements of the system can be designed to perform an evaluation, or other elements can be triggered or driven to perform an evaluation, thereby initiating the evaluation.

  Based on the evaluation, the system element will then perform the necessary adaptive action itself in view of the comparison result, or any other possible system element will begin to do so. Can be made. To that end, a system element can send a message to any other system element to trigger an adaptive action that the system element recognizes that needs to be done in view of the evaluation results.

  The elements of the system that receive system changes, start and / or execute evaluations, and / or start and / or execute adaptive actions are aspects, advice, and points It can be one of a cut, weaver, or other (separate) element for evaluating a notification and initiating an adaptive action.

  According to an embodiment, the step of notifying the element of a change in the base system includes automatically sending the corresponding notification to the element when a change occurs in the base system. And / or polling the base system to observe the base system as to whether any changes are occurring in the base system.

  According to one embodiment, one or more elements of the aspect system, such as advice, pointcuts or the aspect itself, are registered to be notified about any changes in the base system. This ensures that these registered aspects, advices or pointcuts are notified of system changes. This registration scheme allows efficient notification by not notifying system elements that are not registered to receive such notifications.

  According to an embodiment, the evaluation includes determining either or both of a series of all join points and join point shadows for an aspect after the change. This confirms the importance of system changes for an aspect or advice.

  According to an embodiment, the method comprises comparing one or both of a series of join points and join point shadows determined after the change with a corresponding series before the change. And an adaptive operation to compensate for the change if they are different. This gives the possibility of appropriately selecting one from a group of possible adaptive actions based on this comparison result. This makes it possible to check whether all join point shadows that should have been incorporated after a system change are actually incorporated. Next, one of a plurality of possible adaptive actions is selected according to the result. Adapt by performing adaptive actions only on aspects or advice that are deemed important in the evaluation, i.e. by reweaving or unweaving only those aspects that have been found to be required by the evaluation The operation can be executed efficiently.

  According to one embodiment, the present invention includes the step of evaluating a series of rules that determine which of the adaptive actions to use based on the evaluation result. This ensures that the evaluation results are taken into account reliably and appropriately and that an adaptive action appropriate to the particular system change can be selected with certainty. This rule also takes into account events or conditions that occur during runtime, eg, user interaction or evaluation of any function or module.

  According to some embodiments, the base system changes include one or more of the following: addition, removal or modification of elements of the base system.

  According to certain embodiments, a computer program is provided that includes computer-executable code for performing the method according to one of the embodiments of the present invention.

  According to yet another embodiment, an apparatus is provided for adapting to changes in the base system in an aspect-oriented programming environment that includes an aspect system that performs an aspect to be weaved to a base system using a weaver. In response to a change in the base system, an apparatus evaluates the importance of the change in the base system and, if the evaluation reveals that the change is significant, to compensate for the change Means for performing an adaptive operation.

  Such a device can be implemented as software or hardware or a combination of both. According to yet another embodiment, the present invention comprises means for implementing the functions defined in the method according to the embodiment of the present invention. Such means can be implemented as software or hardware or a combination of both.

It is a figure which shows schematically the structure of the aspect which uses a weaver, and a base system based on a prior art. FIG. 6 schematically illustrates a problem that may occur when a system change occurs in a prior art system. Fig. 2 schematically illustrates a method according to an embodiment of the invention. FIG. 6 schematically illustrates a method according to yet another embodiment of the invention. It is a figure which shows schematically the fundamental structure for performing notification based on embodiment of this invention. FIG. 3 schematically illustrates another method according to an embodiment of the invention. FIG. 6 schematically illustrates a system according to yet another embodiment of the invention. FIG. 6 schematically illustrates a system according to yet another embodiment of the invention. FIG. 6 schematically illustrates a system according to yet another embodiment of the invention. FIG. 6 schematically illustrates a system according to yet another embodiment of the invention. FIG. 6 illustrates an exemplary example of program code for executing an embodiment according to the present invention. 1 schematically illustrates a system according to an embodiment of the invention. FIG. 6 schematically illustrates a method according to yet another embodiment of the invention.

FIG. 1A shows the individual modules M ₁ , M ₂ , M ₃ ,. . . , M _n is schematically represented. These modules are software modules, hardware modules associated with specific software modules (eg, drivers for hardware), and the like. For example, in the case of a network, the elements M _{1 to} M _n mean individual hardware parts of the network such as terminals, routers, switches and their corresponding driver parts. On the other hand, an element can be a software component that represents or enables some functionality, such as, for example, the entire system or a specific function given to a user.

On the right side of FIG. 1A, aspects A ₁ -A _k are schematically shown as circles 110. The term “aspect” is used herein to refer to an aspect used in an aspect-oriented programming environment, ie, a specific module used to perform a crosscut in a base system. . To this end, these aspects are weaved to the base system 100 by a weaver 120 to create a runtime structure of the base system, shown schematically as a cloud 130. In this cloud 130, advice codes associated with one or more aspects A ₁ -A _k are invoked in a particular join point shadow, ie a so-called adapted join point shadow, shown as a point in FIG. 1A. Join point shadows to be adapted are associated with aspects A _{1 to} A _k , respectively, and point cuts (join point descriptions in the base system 100) that mean a series of join point shadows in which adaptation operations are performed in the base system 100. ). By describing the joinpoint shadow to be adapted, the pointcut allows the weaver to execute so that the advice code is called in the so-called adapted joinpoint shadow and executed to implement the crosscut problem in the base system. The base system can be modified. This results in a configured system 130 (post-weaving system), schematically shown as cloud 130 in FIG. 1A. In this figure, the adapted join point shadow is shown as a point. To illustrate what happens when the base system 100 changes, reference is now made to FIG. 1B.

In FIG. 1B, 1 single element or elements M ₂ of the base system 100 is removed from the base system. This indicates that certain hardware elements such as certain software modules or terminals in the network are removed. In addition, a (new) module M _{n + 1} has been added to the base system of FIG. 1B.

It has to be noted here that each aspect A ₁ -A _k is called a join point (meaning a corresponding join point shadow) passing through its respective point cut in the base system. However, where the removal of the module M _2, since the module that was present in the base system has been removed, resulting in the fact that several joinpoint the base system no longer actually present. If this is the case, the runtime configuration 130 of FIG. 1A includes an adapted join point shadow that represents an element in the base system that is no longer actually present (module M _{2 in} this example). This is schematically illustrated by the adapted join point shadow that is removed in the runtime system 130 ′ in FIG. 1B. These join point shadows have become unnecessary due to the fact that the corresponding module (module M ₂ ) in the base system has been removed from the base system.

Furthermore, by adding a new module M _{n + 1} to the base system 100, the runtime configuration in which the aspects A _{1 to} A _k should actually include additional adapted join point shadows corresponding to the newly added module M _{n + 1.} The fact that it corresponds to 130 'results. However, since module M _{n + 1} does not exist in the base system when weaving is performed, the join point shadow corresponding to this module is not applied during weaving, and this module M _{n + 1} does not actually exist. This is schematically illustrated by the empty circle in element 130 ′ of FIG. 1B. This is because a weaving system configured at a particular time is no longer accurate when system changes occur within the base system, even with the actual base system and its corresponding aspect, using corresponding join points and join point shadows. Means that it cannot be reflected. This can lead to inconsistencies or errors during runtime and operation of the entire system.

  To overcome this disadvantage, one embodiment of the present invention illustrated in connection with FIG. 2 is provided. FIG. 2 shows a flowchart illustrating a method according to one embodiment of the invention. In step 200, some change occurs in the base system, such as those illustrated in connection with FIGS. 1A and 1B. Based on such changes, step 210 evaluates the importance of this change for one or more aspects weaved to the base system. Then, in a subsequent step 220, an adaptation action is performed to adapt to the system change based on the importance of the system change evaluated in step 210.

  The act 210 of evaluating the importance of system changes in the base system includes, for example, an aspect and its pointcut (or its joinpoint description), and join points added and referenced by this aspect after the system change. Or consist of assessing whether there is a change in the join point shadow. This can be done as further described in connection with FIG.

  FIG. 3 schematically illustrates a flowchart according to yet another embodiment of the present invention. In FIG. 3, a particular aspect is weaved into the base system at a particular time (step 300). Next, in step 310, a system change occurs as previously described in connection with FIGS. 1A and 1B. Next, at step 320, either or both of a series of join points and join point shadows corresponding to the combination of aspect and base system after the system change is calculated or determined. This results in each aspect having either or both of a series of join points and join point shadows that need to perform an adaptive action to ensure that the aspect is properly weaved to the base system. Next, in step 330, for a particular aspect, the series resulting from step 320 is compared to the same series of join points or join point shadows determined or calculated at the time the aspect was weaved. In other words, the series before the system change is compared with the series after the system change. Then, in step 340, if it is determined that the two sequences are different, the system change is important for this aspect, and any adaptive action (to compensate for the system change and its effect on the aspect) Step 350) needs to be performed. One way to perform the adaptive action is to re-weave the aspect, in other words, go back to step 300 and weave the aspect again to the now changed base system. However, if it is found in step 340 that the aspect refers to a join point or join point shadow that no longer actually exists (corresponds) in the base system, the aspect in the base system is re-weaved (re-created). Instead of installing, this aspect can be removed (deinstalled or unweaved). That is, the adaptive action performed in this case is to delete (remove or remove) this aspect (partially or entirely).

  A series of comparisons (step 330) is performed for each aspect, and based on the results, some aspects are re-weaved, some are unweaved, and some do not require any manipulation.

  With reference to FIG. 4, the notification regarding the change of the system by embodiment of this invention is demonstrated. When the base system 400 changes, notifications about system changes are preferably sent automatically to the system element 410. Element 410 can be any element that can evaluate system changes and initiate appropriate adaptive action. According to one particular embodiment, system elements 410 include aspects or advices registered with the base system that are associated with any base system and that aspects or advice are notified about any changes in the base system. can do. Such registration for receiving notifications can be easily performed, for example, in a small talk language which is a programming language. This programming language Small Talk provides a framework for registering with the base system to be notified when the system changes. As a result, you are notified of the aspect or advice that you have registered as related to such information, and then re-evaluated the pointcut and a series of joinpoints or joinpoints as described previously. Once the shadow is determined and the difference between the series of join points or join point shadows before the system change is found, the aspect or advice initiates an adaptive action, such as reweaving the aspect or advice. According to certain embodiments, registering aspects or advice for system changes, such as specific changes related to aspects (changes in specific parts or modules of the system), may be general or specific be able to.

  However, element 410 can also be a weaver that serves to weave aspects into the base system. The weaver then evaluates whether the system change is significant and if it turns out, it initiates an adaptive action, such as reweaving one or more aspects or advice.

  However, element 410 can also be formed by a particular system element that is responsible for receiving the notification (and possibly only the first) and performing the evaluation. This element then determines which aspects or advice are affected by system changes and then sends a message to the aspect and / or advice and / or weaver to initiate an adaptive action. .

  The (automatic) notification to system element 410 can be considered a “push model”, but the system system can also actively poll the base system for any changes. This can be regarded as a “pull model”. One specific embodiment of such a pull model is schematically illustrated in FIG. The base system adds, removes, or modifies system elements that may change the set of join points or join point shadows associated with one or more aspects installed, weaving, or configured within the base system. Such system changes are monitored or polled (step 200 in FIG. 2). If this is acknowledged at step 510, the system element 400 (see FIG. 4) is notified. Once a system element (which can be an aspect, advice, specific element or weaver) is notified, an assessment (steps) of the importance of system changes is made separately for each aspect or advice of the entire system. 430). If the system change is found to be important, the adaptive action is performed as already described above. When a system change occurs, the base system is monitored (steps 400-420) so that those elements involved in the change notification are automatically notified of the system change. This can be regarded as a “push model”. In this case, the aspect registers with the system to be notified about some system change. Or if another so-called “pull model” is used, the aspect actively polls the base system to find any system changes. Any combination of a push model and a pull model can be considered.

  According to one particular embodiment, the present invention can be carried out using the computer language “Smalltalk” or a language called “Squeak” in one of its dialects. A description of aspect-oriented programming using this language “Squeak” can be found in, for example, R.A. Hirschfeld, “AspectS-Aspect-oriented programming with Squaak”, Aksit, Mezini, United, et al. Yes.

  As noted above, language squeaks or small talks make it relatively easy to monitor aspects of the base system being executed and any system changes that may affect their corresponding join points or join point shadows. Provides an infrastructure for notification of system changes and changes that can be used to To that end, the advice associated with an aspect can be registered for system change events such as the addition, modification or removal of types or methods.

  When changes occur, system elements such as advice, aspects, weavers, pointcuts or any other element of the entire system that are registered to notify such changes are notified of this change. In the foregoing embodiment, the information pertains only to the addition, modification or removal of types or methods. According to one embodiment, notification can also be made “just before” a system change occurs.

  As already mentioned above, the information about the system change triggers the evaluation of the importance of the system change for a particular aspect, and if found to be important, the adaptive action is performed as described above.

  To confirm the importance of a system change, according to one embodiment, the aspect first installs and weaves a set of join points or join point shadows of the aspect or advice after the system change, A comparison is made with the series when the assembly is performed or when an adaptive action has been previously performed in response to a previous significant change event. In other words, the new series of join points or join point shadows after the system change is compared to the series of join points or join point shadows currently associated with the aspect. The result of this comparison is that both lists, or series, differ so that the set of joinpoint shadows actually associated with the aspect is different from the series that actually needs to be associated with the aspect If it reaches, adaptive operation is performed.

  According to one embodiment, the adaptive action that is taken when a system change that is found to be significant includes several actions that may be taken instead or in combination. Such actions include software installation or uninstallation, component startup and / or shutdown, module loading and unloading or both, or replacement, and aspects and advice. And / or reweaving or unweaving.

  Yet another example of an embodiment according to the present invention is described in connection with FIGS. 6A-6D. FIG. 6A schematically illustrates conventional aspect weaving in a general manner for aspect-oriented programming that is performed in a particular language or squake and uses a squa called AspectS. For more details on aspect-oriented programming using this language, see the above mentioned article by R. Hirschfeld. A more detailed description of FIG. 6A is also described therein.

  According to AspectS's method, an aspect contains one or more advices. Each advice contains one or more pointcuts, and the pointcut itself contains a joinpoint description for setting joinpoints in the base system. The join point descriptor identifies the selector (method) and the class (as the receiver that receives the advice) that executes the selector to define the join point. The advice further includes one or more advice identifiers that allow the description of the dynamic attributes of the pointcut associated with the advice. In addition, the aspect includes code for executing advice. For this reason, AspectS uses a block that is an instance of a class block context that represents the code for executing the advice. The upper half of FIG. 6A schematically illustrates an aspect in an AspectS environment, and a weaver is schematically illustrated in the center of FIG. 6A. This weaver weaves the aspect illustrated in the upper half of FIG. 6A to a base system (not shown). In order to weave the aspect into the base system, AspectS places the position of the so-called block method wrapper in the receiver class method dictionary listed in the various join points advised by the aspect. This is schematically illustrated in the lower half of FIG. 6A. This creates a configuration system where the weaver is weaved to the base system as shown in the bottom line of FIG. 6A. AspectS places block method wrappers in the method dictionary of the receiver class listed in the various join points advised by the aspect.

  An equivalent of the runtime of the configuration system configured by the weaver is shown schematically in FIG. 6B. Based on the advice, pointcuts and their associated join point descriptors, a method wrapper is used to allow execution of the advice code by a corresponding block context calculation. A more detailed explanation of the foregoing can be found in the above R. Hirschfeld document.

  Having described a conventional scheme for AspectS, an embodiment according to the present invention for executing AspectS, for example, will now be described with reference to FIGS. 6C and 6D. FIG. 6C schematically illustrates how an aspect and its corresponding advice are modified to deal with changes in the base system in accordance with the present invention. As can be seen from FIG. 6C, the advice identifier refers to an adaptive action strategy (which also corresponds to the execution of a block context). Thereby, as described above, the operation of the embodiment according to the present invention is executed. An adaptive motion strategy includes the steps of evaluating for any system changes, determining the appropriate motion to be performed, and initiating such motion. Based on the environment (assessment to system changes), various reactions can be performed, such as reweaving aspects or advice, or deleting aspects or advice, as schematically illustrated in FIG. 6C.

  Supports a series of join points or join point shadows that are used and executed in an already weaved (“active”) system to evaluate system changes and trigger adaptive actions when needed Or an “active pointcut” that reflects them is provided. After a system change occurs, a (new) pointcut or a corresponding series of join points or a join point shadow for the changed system is evaluated, and an existing pointcut (“valid pointcut”) or its corresponding Compared to a series of join points or join point shadows. If it is found that there is a (significant) difference, the appropriate adaptive action is taken.

  This is explained in more detail in the block diagram shown in FIG. 6D. In FIG. 6D, in addition to FIG. 6C, individual steps to be executed based on the embodiment of the present invention are also shown. Advice regarding system changes (event a) is notified. Instead of the aspect or advice, other system elements other than the aspect are notified as well or instead, as indicated by a * in FIG. 6D. The notified system element must be an element capable of performing either the importance confirmation and the adaptation operation, or it must be able to initiate the importance confirmation and the adaptation operation. Now, FIG. 4 and corresponding elements 410 will be described.

  The system element then notifies the aspect or advice that is likely to change and be significant. Next, importance is confirmed and correction is started (step b). Thereby, the calculation of the point cut is started as a series of join points and join point shadows (step c). The result is then a pointcut that is actually in operation, i.e. a pointcut as used before the system change or in the current (weaved) system or its corresponding series of joinpoints, join It is compared with the point shadow (step d). If it is found that there is some difference between the active pointcut and the new pointcut after the system change, an adaptive motion strategy is called (step e) to deal with or compensate for system changes. In order to do this, an adaptive operation is performed.

  Hereinafter, examples of specific specific examples of embodiments according to the present invention will be described. This illustrative example is based on Squak, a small talk dialect and a programming language well known to those skilled in the art. An explanation of the concept of aspect-oriented programming by Squeak is in the literature by R. Hirschfeld above.

  FIG. 7 shows C01, C02 and C03 which are elements of the program code. C01 and C02 indicate program codes for advice corresponding to aspects related to the movement of the mouse, which are named “adviceMouseEnter” and “adviceMouseLeave”, respectively. C01 defines a program code for advice to be executed when the mouse is input, and C02 indicates a program code for executing the advice when the mouse is left (respectively input a mouse). Or in the event of a mouse corresponding to neglect). Pointcuts include the location where the method (or selector) "mouseEnter" (for adviceMouseEnter) and "mouseLeave" (for adviceMouseLeave) are executed in Morph (an exemplary class) and all its subclasses Contains join point descriptions.

  C03 shows exemplary code for weaving an aspect belonging to these two advices called AsMorphicMousingAspect.

  The program codes shown in the embodiments C01 and C02 are conventional embodiments for executing advice for mouse input and mouse leaving. C01 and C02 cannot cope with any system changes in the underlying base system.

  The program code shown in block C04 provides an example of advice that can handle any changes in the base system performed by this advice. C04 gives an example of a program code for an input event of a mouse, and C05 gives an example of a program code for an advice related to leaving the mouse.

  It can be seen that the advice includes an identifier. Such an identifier allows a description of the dynamic attributes of the join point or set of join point shadows associated with the advice or aspect (eg, described by a pointcut). A more detailed explanation of the function of such an identifier can be found in the literature by R. Hirschfeld above. The identifiers of blocks C04 and C05 are different from those of conventional code, i.e. they refer to an adaptive action module (called "adaptation") and a module to reinstall advice (called "reinstall advice") It is understood that it includes.

  “Adaptation” monitors the system for changes in the system, refers to system elements to evaluate these system changes, and finds that the change in this system is important. The code or element that executes is called to deal with the change. With this identifier, the advice given in blocks C04 and C05 can cope with any system change by reinstalling the advice, if necessary, after the system change.

  According to one embodiment of the invention, there are three different entities for implementing the system according to the invention. One entity is a base system, which comprises the modules or elements that form the base system. The aspect model (sometimes called an aspect element or aspect system) is different from the base system and is separate from it. This aspect model may be formed by or comprise elements or modules that perform aspects, advice, pointcuts, etc. Together with the base system, the aspect model or aspect system forms the overall system formed by the aspect model or aspect system that performs the base system and cross-cut problems within the base system.

  A third entity that forms part of the overall system is an adaptive system or adaptive operating element that provides the possibility to react in a adaptive manner to changes in the base system.

  The three systems (base system, aspect system, adaptive system) are separate and separated from each other in the sense that each system is a separate entity. Each entity according to one embodiment is constructed using a framework of rules and corresponding expressions (such as programming languages) that execute or design the entity. Each entity (base system, aspect system, adaptive system) comprises a separate module or element. This is shown schematically in FIG. In this figure, the base system is shown schematically as box 810. The base system of this figure corresponds to the base system also shown in FIG. 1A and, in one embodiment, runs in a computer language squeak, which is a more general purpose computer language small talk dialect. Can do.

  In addition to the base system, there is another model, the aspect system 820 (see FIG. 8) as a different entity. In one embodiment, the aspect system 820 includes an aspect that includes advice elements (not shown) and pointcuts (not shown) that select join point shadows in the base system 810 that need to call the advice code. 825.

  The aspect system is a separate entity and is separated from the base system in the sense that it can be executed and modified independently of the base system.

  Through the weaver 835, the aspect or advice defined in the aspect system is weaved into the base system 810, thereby forming a configuration system 840 ready for execution. According to embodiments of the present invention, it is necessary to adapt to any changes in the configuration system (or base system or aspect system).

  In order to be able to adapt to changes in the system, an additional element (third element) of the overall system, an adaptation system 860, is provided. An adaptive system according to one embodiment includes elements that receive notification about any change in the base system and then evaluate the change. The adaptation system further comprises an action selector that performs a selection of actions according to one embodiment. This action selector is a set of rules for defining what kind of system change or what kind of evaluation result should lead to what kind of adaptive action to be performed. It further comprises an element for either starting or executing an adaptive action that has been found necessary based on a decision made by the action selector. The adaptive system can then cause the weaver to perform an action to perform the adaptive action. This includes reweaving aspects or advice of aspect system 820, and also includes unweaving aspects or advice.

  As described above, the base system, aspect system, and adaptation system are separate entities. These entities interact through appropriate interfaces, typically direct or indirect calls to procedures, methods or functions. This provides great flexibility because these three entities can be executed and modified independently of each other.

  The adaptation system 900 is further described with reference to FIG. Observer 910 receives notifications about changes in the base system. Next, the evaluator 920 connected to the observer evaluates whether the system change is significant. If so, the action selector 930 determines or selects which adaptive action actually needs to be performed. To that end, the action selector 930 is based on the evaluation results to determine how it is determined and what adaptive action to perform (sometimes referred to as an “adaptive action strategy”). Run the rule. The action selector then selects this action or adaptive action strategy from the pool 950 where there are multiple possible adaptive action strategies, such as full or partial reweaving, full or partial unweaving. The selected adaptive action strategy is then transferred and used by the executing weaver 960. This results in a changed configuration model 970. It will be readily appreciated that if any other change occurs in the configuration model or base system, the entire procedure starting from the observer 910 will be triggered again.

  Here, the evaluation regarding the change of the system by another embodiment is demonstrated in detail. The evaluator 920 receives notifications from the observer 910 regarding changes in the base system. As described above, this change is then evaluated, resulting in one of several possible evaluation results. As a result of this, for example, if a system module is added after a system change, the weaver should weave more join point shadows, and if the system module is removed, the weaver will have less join point shadows. A pointcut indicates that weaving should be done. This has already been explained in connection with the previous embodiment.

  Based on the evaluation result, the action selector 930 next determines which operation (adaptive operation strategy) actually needs to be performed. The action selector 930 determines the adaptive action strategy to use according to the following specific rules: For example, if we need to weave more join point shadows after a system change, an adaptive motion strategy selected from pool 950, a set of possible methods, weaves the aspect to the base system. That is.

  The result of the evaluation in another case is that we need to weave fewer join point shadows after a system change. At this time, the operation selected based on the adaptive operation strategy is that the aspect is unweaved from the base system. Next, the weaver is notified by the adaptation module that unweaving should be performed.

  It has been previously described that the base system, aspect model, and adaptive behavior model are three separate entities. However, according to certain embodiments, some portions of the adaptive system can be implemented as elements or portions of an aspect model. For example, the observer 910 can be executed as part of the aspect or advice, for example by registering the aspect or advice for system changes, as already described above. Here, when an aspect, advice receives a notification about a change in the system, it initiates the evaluation (eg, by a function call) or performs the evaluation itself. Since the aspect and advice are associated with a specific pointcut, it is possible to check whether the system change is important for the specific aspect and advice. This can be done by evaluating point cuts before and after the system change, as described above. This makes it possible to execute evaluations on individual aspects and advice. This is advantageous because certain changes in the base system are not necessarily important for all aspects and advice. After the evaluation performed by the aspect, advice itself through a function or procedure call, the action selector is then called to determine the appropriate adaptive action strategy. In this embodiment, the observer and evaluator are executed as part of the aspect system, and then the aspect system calls the adaptive system after evaluation to select the appropriate adaptive action strategy and begin execution.

  According to the previous embodiment, the observer and evaluator (elements 910 and 920 in FIG. 9) are part of the aspect system, but according to another embodiment, these elements are instead part of the weaver. Form. For example, a weaver receives a notification about a system change and evaluates the system change or initiates an evaluation (through a function call). When weaver himself evaluates system changes, weaver transfers the evaluation results to the adaptive system. Since the action selector of the adaptive system has a role of selecting an adaptive action, it selects an appropriate adaptive action and starts its execution.

  Thus, according to the previous embodiment, the observer 910 and evaluator 920 shown in FIG. 9 are not part of the adaptive system but part of the aspect system or weaver. Again, the adaptive system, aspect system, and base system remain three separate entities that communicate through direct or indirect calls.

  As described above, the adaptation rules executed in the action selector reflect the correspondence between system changes or their evaluation and the adaptation actions that need to be performed (the selected adaptation action strategy). This correspondence can be defined, for example, by defining which system changes result in a specific adaptive action to be performed (default adaptive action), for example, during programming. According to another embodiment, the decision to perform an adaptive action is determined during runtime, such as an evaluation of other modules or functions, or an evaluation of user input (during runtime). It is executed depending on the parameter. For example, when adding a new system element, the user is asked if this system element needs to be observed, for example by logging or tracking procedures, and if so, in response to the user's acknowledgment, An appropriate adaptive action strategy is selected, which means for example that reweaving is performed.

  Selection of adaptive action strategies is typically done during runtime by referring to rules executed in the action selector, and these rules are based on the designer's preference to achieve the desired adaptive action capability. Can be executed.

  Although the invention has been described in connection with the above embodiments, they are used for purposes of illustration only and should not be construed as limiting the invention, and are also within the spirit and scope of the invention. Those skilled in the art will readily understand that modifications can be made without departing. In particular, it should be apparent that the present invention can be implemented in software, hardware, or a combination of both. The elements of the present invention can be realized by hardware, software or a combination of both. Although reference has been made to a particular programming language in the description, it should be understood that the invention can be implemented using any suitable computer and any suitable programming language. Further, it is to be understood that the exemplary program code is used by way of example only to illustrate the principles of the invention and therefore should not be understood as limiting the invention. Embodiments of the invention can be implemented in software, hardware, or a combination of both.

  For example, according to one embodiment, an apparatus performing an embodiment of the present invention is adaptively adapted to perform the functions described in connection with previous embodiments of the present invention, and is a computer or computer system. It has a weaver attached to it. According to another embodiment, an apparatus performing an embodiment of the present invention is adaptively adapted to perform the functions described in connection with previous embodiments of the present invention, and is a computer or computer system. It has an aspect system that can be attached to. According to yet another embodiment of the present invention, an apparatus implementing an embodiment of the present invention can function as a computer or computer system as described in connection with one or more previous embodiments of the present invention. It can be any computer or computer system in which the software to be installed is incorporated.

Claims (34)

A method for adapting to changes in a base system in an aspect-oriented programming environment that includes an aspect system that implements an aspect to be weaved to the base system using a weaver, comprising:
Assessing the importance of the change in the base system in response to a change in the base system;
Performing an adaptive action to compensate for the change if the evaluation reveals that the change is significant. The step of assessing the importance of the change comprises:
Determining whether a join point or join point shadow in the base system after a change in the base system is different from a post-change in the base system. The method described in 1. Individually performing said importance assessment for an aspect or advice;
3. A method according to claim 1 or 2, further comprising the step of individually performing an adaptive action on the certain aspect or advice found to be significant for the change. The adaptive action is:
Reweaving an aspect to the base system in whole or in part;
Reweaving the advice associated with an aspect in whole or in part,
Unweaving an aspect in whole or in part;
4. An adaptive action as claimed in any one of claims 1 to 3, which is selected from a plurality of adaptive actions including two or more of the steps of fully or partially unweaving advice associated with an aspect. The method described. The aspect-oriented programming environment includes an adaptive system in addition to the base system and the aspect system,
The adaptive system, the base system and the aspect system are separate entities that can be modified and executed independently of each other.
The method as described in any one of Claims 1-4.   The method according to any one of claims 1 to 5, wherein the base system, the aspect system and the adaptive system interact through direct or indirect calls. In the case where a change occurs in the base system, the method further includes a step of notifying a change in the base system to elements of the overall system including the base system, the aspect system, and the adaptive system. The element is
Initiating an assessment of changes in the base system;
Assessing changes in the base system;
Starting an adaptive action based on the evaluation;
One or more of performing an adaptive action based on the evaluation,
The method according to any one of claims 1 to 6. Said element is
Aspect,
With advice,
With weaver,
With point cuts,
The method of claim 7, wherein the method is one of any other elements of the overall system. Notifying the element of changes in the base system comprises:
Automatically informing the element when a change occurs in the base system by sending a corresponding notification to the element;
Polling the base system with the element to monitor the base system for any change in the base system, comprising one or both of: The method described in 1.   10. A method according to any one of the preceding claims, comprising registering one or more elements of the aspect system to be notified of any changes in the base system. Assessing a change in the base system comprises:
Determining, after the change, either or both of a series of all join points and a series of all join point shadows for either or both of an aspect and advice. Item 11. The method according to any one of Items 1 to 10. Comparing either or both of the series of join points and the series of join point shadows determined after the change with a corresponding series before the change;
12. The method of any one of claims 1 to 11, further comprising: performing an adaptive action to compensate for the change if the series is different. Providing a plurality of possible adaptive actions as an adaptive action strategy to be performed;
The method according to claim 1, further comprising selecting one or more of the plurality of adaptive actions in response to the evaluation. The step of evaluating the importance comprises
The method according to claim 1, further comprising: evaluating a series of rules that determine which of the adaptive actions should be performed based on the evaluation result. The step of assessing importance takes into account events or actions that occur during runtime;
The event or interaction is
User interaction,
One or more of a function or module evaluation during runtime,
15. A method according to any one of claims 1-14.   16. A method according to any preceding claim, wherein the base system change comprises one or more of addition, removal or modification of elements of the base system.   A computer program comprising computer-executable code for performing the method according to claim 1.   A data storage medium comprising or embodying the computer program according to claim 17. An apparatus for adapting to changes in a base system in an aspect-oriented programming environment including an aspect system that implements an aspect to be weaved to a base system using a weaver,
Means for assessing the significance of the change in the base system in response to a change in the base system;
And means for performing an adaptive action to compensate for the change if the evaluation reveals that the change is significant. Means for assessing the importance of the change are:
Means for determining whether a join point or join point shadow in the base system after a change in the base system is different from a post-change in the base system. Item 20. The device according to Item 19. Means for individually performing the importance assessment for an aspect or advice;
21. The apparatus of claim 19 or 20, further comprising means for individually performing an adaptive action on the certain aspect or advice found to be significant for the change. The adaptive action is:
Reweaving an aspect to the base system in whole or in part;
Reweaving the advice associated with an aspect in whole or in part,
Unweaving an aspect in whole or in part;
23. The method according to any one of claims 19 to 21, wherein the adaptive action is selected from a plurality of adaptive actions including two or more of the steps of unweaving, in whole or in part, advice associated with an aspect. The device described. The aspect-oriented programming environment includes an adaptive system in addition to the base system and the aspect system,
The adaptive system, the base system and the aspect system are separate entities that can be modified and executed independently of each other.
The apparatus according to any one of claims 19 to 22.   24. The apparatus according to any one of claims 19 to 23, wherein the base system, the aspect system, and the adaptive system interact with each other through direct or indirect calls. When a change occurs in the base system, it further comprises means for notifying changes in the base system to the elements of the overall system including the base system, the aspect system and the adaptive system. The element is
Initiating an assessment of changes in the base system;
Assessing changes in the base system;
Starting an adaptive action based on the evaluation;
One or more of performing an adaptive action based on the evaluation,
The device according to any one of claims 19 to 24. Said element is
Aspect,
With advice,
With weaver,
With point cuts,
26. Apparatus according to any one of claims 19 to 25, which is one of any other element of the overall system. Means for notifying the element of a change in the base system,
Means for automatically notifying the element when a change occurs in the base system by sending a corresponding notification to the element;
26. Means for polling the base system by the element to monitor the base system for any change in the base system, or both. Or the apparatus according to 26.   28. Apparatus according to any one of claims 19 to 27, comprising means for registering one or more elements of the aspect system to receive notifications about any changes in the base system. The means for evaluating the change in the base system is:
After said change, means for determining either or both of a series of all join points and a series of all join point shadows for one or both of an aspect and advice An apparatus according to any one of claims 19 to 28. Means for comparing either or both of the series of join points and the series of join point shadows determined after the change with a corresponding series before the change;
30. The apparatus of any one of claims 19 to 29, further comprising means for performing an adaptive action to compensate for the change if the series is different. Means for providing a plurality of possible adaptive actions as an adaptive action strategy to be performed;
31. The apparatus according to any one of claims 19 to 30, further comprising means for selecting one or more of the plurality of adaptive actions in response to the evaluation. The means for evaluating the importance is:
The apparatus according to any one of claims 19 to 31, further comprising: means for evaluating a series of rules for determining which of the adaptive operations should be performed based on the evaluation result. The means for assessing importance takes into account events or actions that occur during runtime;
The event or interaction is
User interaction,
One or more of a function or module evaluation during runtime,
33. Apparatus according to any one of claims 19 to 32.   23. The apparatus of any one of claims 19-22, wherein the base system change comprises one or more of addition, removal or modification of elements of the base system.

Images