Using common off-the-shelf tools to implement dynamic aspects

William R. Mahoney, William L. Sousan

Research output: Contribution to journalArticle

5 Citations (Scopus)

Abstract

An emerging software engineering paradigm, Aspect-Oriented Programming, can be used to facilitate moving common interests or requirements from individual software functions into a separate module. Aspect code is woven into the software on either a static (compilation) basis or dynamic (runtime) basis. Existing systems necessitate the use of syntactic sugar, which is added to programs to indicate the join points in the software where aspects could potentially be applied. Static weaving inserts code, at compilation time, into these join points, while dynamic weaving might compile in code which can be activated at runtime. This paper describes a new approach to the implementation of dynamic aspects in C/C++. Our method uses a tool which operates using the GCC compiler suite on Linux; it is a runtime event monitoring system we call "dynamicHook". The tool tests each potential join point at run time for the required activation of advice. If advice code is necessary at the join point it is loaded on the fly from shared libraries, retained for future use, and called dynamically. No additions or modifications to the source code need to be made other than recompiling and linking in our library. The tool is thus targeted at adding aspect oriented methodologies to existing C/C++ code. We have demonstrated the tool by obtaining open-source web servers and adding dynamic aspects dealing with security and intrusion detection.

Original languageEnglish (US)
Pages (from-to)34-41
Number of pages8
JournalACM SIGPLAN Notices
Volume42
Issue number2
StatePublished - Feb 1 2007

Fingerprint

Aspect oriented programming
Intrusion detection
Syntactics
Sugars
Software engineering
Servers
Chemical activation
Monitoring
Linux

Keywords

  • Dynamic aspects
  • Event monitoring
  • GCC
  • Intrusion detection
  • Open-source

ASJC Scopus subject areas

  • Computer Science(all)

Cite this

Using common off-the-shelf tools to implement dynamic aspects. / Mahoney, William R.; Sousan, William L.

In: ACM SIGPLAN Notices, Vol. 42, No. 2, 01.02.2007, p. 34-41.

Research output: Contribution to journalArticle

@article{67c1a267be0a4403ae235396985a30c3,
title = "Using common off-the-shelf tools to implement dynamic aspects",
abstract = "An emerging software engineering paradigm, Aspect-Oriented Programming, can be used to facilitate moving common interests or requirements from individual software functions into a separate module. Aspect code is woven into the software on either a static (compilation) basis or dynamic (runtime) basis. Existing systems necessitate the use of syntactic sugar, which is added to programs to indicate the join points in the software where aspects could potentially be applied. Static weaving inserts code, at compilation time, into these join points, while dynamic weaving might compile in code which can be activated at runtime. This paper describes a new approach to the implementation of dynamic aspects in C/C++. Our method uses a tool which operates using the GCC compiler suite on Linux; it is a runtime event monitoring system we call {"}dynamicHook{"}. The tool tests each potential join point at run time for the required activation of advice. If advice code is necessary at the join point it is loaded on the fly from shared libraries, retained for future use, and called dynamically. No additions or modifications to the source code need to be made other than recompiling and linking in our library. The tool is thus targeted at adding aspect oriented methodologies to existing C/C++ code. We have demonstrated the tool by obtaining open-source web servers and adding dynamic aspects dealing with security and intrusion detection.",
keywords = "Dynamic aspects, Event monitoring, GCC, Intrusion detection, Open-source",
author = "Mahoney, {William R.} and Sousan, {William L.}",
year = "2007",
month = "2",
day = "1",
language = "English (US)",
volume = "42",
pages = "34--41",
journal = "ACM SIGPLAN Notices",
issn = "1523-2867",
publisher = "Association for Computing Machinery (ACM)",
number = "2",

}

TY - JOUR

T1 - Using common off-the-shelf tools to implement dynamic aspects

AU - Mahoney, William R.

AU - Sousan, William L.

PY - 2007/2/1

Y1 - 2007/2/1

N2 - An emerging software engineering paradigm, Aspect-Oriented Programming, can be used to facilitate moving common interests or requirements from individual software functions into a separate module. Aspect code is woven into the software on either a static (compilation) basis or dynamic (runtime) basis. Existing systems necessitate the use of syntactic sugar, which is added to programs to indicate the join points in the software where aspects could potentially be applied. Static weaving inserts code, at compilation time, into these join points, while dynamic weaving might compile in code which can be activated at runtime. This paper describes a new approach to the implementation of dynamic aspects in C/C++. Our method uses a tool which operates using the GCC compiler suite on Linux; it is a runtime event monitoring system we call "dynamicHook". The tool tests each potential join point at run time for the required activation of advice. If advice code is necessary at the join point it is loaded on the fly from shared libraries, retained for future use, and called dynamically. No additions or modifications to the source code need to be made other than recompiling and linking in our library. The tool is thus targeted at adding aspect oriented methodologies to existing C/C++ code. We have demonstrated the tool by obtaining open-source web servers and adding dynamic aspects dealing with security and intrusion detection.

AB - An emerging software engineering paradigm, Aspect-Oriented Programming, can be used to facilitate moving common interests or requirements from individual software functions into a separate module. Aspect code is woven into the software on either a static (compilation) basis or dynamic (runtime) basis. Existing systems necessitate the use of syntactic sugar, which is added to programs to indicate the join points in the software where aspects could potentially be applied. Static weaving inserts code, at compilation time, into these join points, while dynamic weaving might compile in code which can be activated at runtime. This paper describes a new approach to the implementation of dynamic aspects in C/C++. Our method uses a tool which operates using the GCC compiler suite on Linux; it is a runtime event monitoring system we call "dynamicHook". The tool tests each potential join point at run time for the required activation of advice. If advice code is necessary at the join point it is loaded on the fly from shared libraries, retained for future use, and called dynamically. No additions or modifications to the source code need to be made other than recompiling and linking in our library. The tool is thus targeted at adding aspect oriented methodologies to existing C/C++ code. We have demonstrated the tool by obtaining open-source web servers and adding dynamic aspects dealing with security and intrusion detection.

KW - Dynamic aspects

KW - Event monitoring

KW - GCC

KW - Intrusion detection

KW - Open-source

UR - http://www.scopus.com/inward/record.url?scp=51349119888&partnerID=8YFLogxK

UR - http://www.scopus.com/inward/citedby.url?scp=51349119888&partnerID=8YFLogxK

M3 - Article

AN - SCOPUS:51349119888

VL - 42

SP - 34

EP - 41

JO - ACM SIGPLAN Notices

JF - ACM SIGPLAN Notices

SN - 1523-2867

IS - 2

ER -