Data processing: software development – installation – and managem – Software program development tool – Testing or debugging
Reexamination Certificate
1999-07-20
2002-10-29
Dam, Tuan Q. (Department: 2124)
Data processing: software development, installation, and managem
Software program development tool
Testing or debugging
C717S127000, C717S114000
Reexamination Certificate
active
06473895
ABSTRACT:
FIELD OF THE INVENTION
The present invention relates generally to system monitors for monitoring various computer/communications resources, and more particularly to an aspect-oriented programming implementation of a system monitor.
BACKGROUND OF THE INVENTION
Modem computer systems generally include many resources, including network access, processing cycles, storage allocation and access, and output device access, among others. With such complex systems some type of administration is typically needed to control and manage the computer system to ensure the efficient operation of the system. For proper administration of the system, it is necessary to monitor for various events occurring within the computer system. These events might include service calls to various resources, completions of service requests, and notifications of errors, among many others. These events are either monitored either by each individual resource sending some form of notification, or by a centralized system monitor which polls each resource to determine a status of the resource.
Prior art system monitors developed using traditional programming languages have some properties that make system monitoring difficult to implement and maintain. In the prior art, implementing the system monitors with traditional programming languages requires that some code for performing system monitoring be intermingled with the code for implementing resource functionality. This results in the weakening of the functional abstractions of both the resource and of the monitoring systems.
Another problem that may be encountered with prior art programming occurs during system development, where a monitoring or tracing function is desired during testing, but not after testing is completed. Since the code for implementing the system monitor is interspersed with code for the resource being developed, the task of removing the system monitoring code after testing involves substantial editing of the software entity embodying the resource. Worse, if the resource needs to be modified after the system monitor code has been removed, the developer must edit the software entity again to replace the monitoring code.
Traditional programming languages typically work well for design decisions that define a unit of functionality, such as a procedure or an object. Procedural languages such as for Fortran, Pascal, and C are useful for defining programs where the execution is straightforward, beginning at a starting point and executing in a stepwise manner to an end. In this model, design issues can be addressed by units of contiguous program execution. Deviations from the straightforward path are provided by function calls which allow program execution to jump from the main routine to the subroutine, and back again to the main routine. The use of subroutines allows for programming efficiency for implementing common routines; however, with programs becoming increasingly more complicated, and the number of common routines also growing, programs written in procedural languages are becoming increasingly complicated and difficult to maintain.
With modem computer programs becoming increasingly long and complex creations which may have many millions of lines of code, the concept of modularity is becoming increasingly important in the development of software. With a modular approach, the various functions of a computer program may be separated into modules which various programmers can work on independently. One popular programming paradigm that embodies the concept of modularity is that of object-oriented programming (OOP).
The central idea behind object-oriented programming is the object model, where all programs are structured as collections of interrelated objects, each of which represents an instance of some class in a hierarchy of object classes.
Object-oriented programming involves defining, creating, using, and reusing “objects,” which can be used to model ideas and things in terms of their features (data) and behaviors (methods). Each object is a self-contained software element including data and methods for operating on the data. Objects are created by defining object classes from which objects are created, or “instantiated.” The object classes are templates for creating objects. Each object created from a particular object class includes all the data and methods of the object class, as well as data and methods from its superclasses, and different objects of the same object class may be used for different purposes. Common object-oriented programming languages include Smalltalk, C++, and Java.
Other, non-OOP approaches are also commonly used, such as embodied in procedural programming languages and functional programming languages.
When design features may be cleanly divided among distinct elements, these approaches capture the benefits of modularity very well. However, these approaches fail to provide the proper support in certain situations, such as those involving shared resources, error handling, or other systemic issues where the same or similar functionality affects or is affected by many different elements.
The reason why these approaches are insufficient is that those issues cross-cut the primary modularization of the systems. Cross-cutting occurs when some particular concern depends on and/or must affect parts of the implementation of several of the functional modules of the system. Functional modules may include such software entities as objects and program modules, among others, and cross-cutting may occur across different software entities, in different places within the same software entities, or a combination of the two. Many cross-cuts are not weaknesses of the designs; they are a natural and unavoidable phenomena in complex systems, and they are the basis for the concept of “aspect.”
Implementing those cross-cutting concerns in traditional programming languages, even object-oriented ones, typically requires scattering bits of code throughout the program, resulting in code that is referred to as “tangled.”
An aspect is a concern that cross-cuts the primary modularization of a software system. An aspect-oriented programming language extends traditional programming languages with constructs for programming aspects. Such constructs can localize the implementation of cross-cutting concerns in a small number of special purpose program modules, rather than spreading the implementation of such concerns throughout the primary program modules. As with other types of software elements, an aspect may include both data and methods.
In order to capture the cross-cutting nature of aspects, such special program modules break the traditional rules of encapsulation in principled ways. They can affect the implementation of software entities implementing primary functionality without the explicit consent of those software entities; further, they can do that for several software entities simultaneously.
Aspect oriented programming (AOP) extends the expressive facilities available to the programmer, so that many design decisions can be expressed locally. The AOP programmer writes the base program in a traditional programming language, and also writes pieces of aspect code, each of which affects executions that are described in some parts of the base program.
In such a manner, aspect code can localize the implementation of some design patterns in a few modules, rather than spreading the fields and methods of those patterns throughout the classes, and can capture the tracing, debugging and instrumentation support for a complex system in a few modules, capture error handling protocols involving several classes in a single module, and capture resource sharing algorithms involving several classes in a single module, rather than as multiple code fragments tangled throughout the classes.
The special program modules for programming aspects enable this by cross-cutting the modularity of classes in principled ways. So one of those special program modules can affect the implementation of several classes (or several methods within a single class) in a c
Choppella Venkatesh
Haveliwala Taher H.
Hilsdale Erik A.
Kiczales Gregor J.
Lamping John O.
Chavis John Q.
Dam Tuan Q.
Wang Peter Y.
Xerox Corporation
LandOfFree
Aspect-oriented system monitoring and tracing does not yet have a rating. At this time, there are no reviews or comments for this patent.
If you have personal experience with Aspect-oriented system monitoring and tracing, we encourage you to share that experience with our LandOfFree.com community. Your opinion is very important and Aspect-oriented system monitoring and tracing will most certainly appreciate the feedback.
Profile ID: LFUS-PAI-O-2992603