Harish Narayanappa

Learn More
Today's aspect-oriented programming (AOP) languages provide software engineers with new possibilities for keeping conceptual concerns separate at the source code level. For a number of reasons, aspect weavers sacrifice this separation in transforming source to object code (and thus the very term weaving). In this paper, we argue that sacrificing modularity(More)
The key notion in service-oriented architecture is decoupling clients and providers of a service based on an abstract service description, which is used by the service broker to point clients to a suitable service implementation. A client then sends service requests directly to the service implementation. A problem with the current architecture is that it(More)
The contribution of this work is the design, implementation and evaluation of a new aspect-oriented invocation mechanism for preserving design modularity in object code. We call our mechanism Bind. We make three basic claims. First, it is feasible to realize a programming model that supports Bind to preserve design modularity in object code. Second, the new(More)
In a service oriented architecture, certain requirements can be tested by observing the interface of the service whereas other requirements such as data privacy, confidentiality and integrity cannot be tested in this way. After deployment , a requirements monitor is used to analyze the conformance of a web service to such requirements. The integrity of the(More)
For a number of reasons, such as to generate object code that is compliant with the existing virtual machines (VM), current compilers for aspect-oriented languages sacrifice design modularity when transforming source to object code by losing textual locality and intermingling concerns in the object code. Sacrificing design modularity has significant costs,(More)
  • 1