What does aspect-oriented programming mean to Cobol?

  title={What does aspect-oriented programming mean to Cobol?},
  author={Ralf L{\"a}mmel and Kris De Schutter},
  booktitle={AOSD '05},
We study AOP in the context of business programming with Cobol. We face the following questions: What are join points in Cobol programs? What is advice? Does classic Cobol provide any constructs that hint at AOP? (Yes!) What are typical crosscutting concerns in the Cobol world? How do otherwise typical crosscutting concerns make sense for Cobol? How does AOP for Cobol align with classic re-engineering transformations for Cobol? We deliver an AOP language design for Cobol. Codename: AspectCobol… 

Figures from this paper

Aspect orientation in the procedural context of C (presentation)
This research focuses on the integration of AOP in C and applied the new aspect language, tools and the AOP methodology to a realistic case study, which provided valuable feedback regarding common legacy C practices and integration issues of Aop tools to existing build processes.
Using Aspect Orientation in Understanding Legacy COBOL Code
In this paper, context aspect and error handling aspect, which are two most important aspects for COBOL code understanding, are defined and the approach for aspect location and operations in COBol code is presented.
Term Rewriting Meets Aspect-Oriented Programming
This work explores the connection between term rewriting systems (TRS) and aspect-oriented programming (AOP) and presents one application: automatically connecting an interactive debugger to a language specification.
Program analysis environment for writing COBOL aspects
The environment and an experience of applying aspect orientation to strengthening internal control in enterprise information systems to improve internal control implemented in a small information system are described.
Face-off: AOP+LMP vs. legacy software
This paper applies a mix of aspect-oriented programming (AOP) and logic meta-programming (LMP) to tackle some concerns of/in legacy environments. We present four different problems, and illustrate
Aspect Orientation for C : Express yourself Position paper
The need for a more complex pointcut language is illustrated by means of a simple and prototypical concern, present in a real-world application, that can not be captured adequately with current-day aspect technologies.
Aspect-orientation For Revitalising Legacy Business Software
Symbiosis in logic-based pointcuts over a history of join points
The unimplementable ideal model of declarative history-based logic pointcut languages is discussed, and the possible approximations that can be made that are still implementable and what limits they impose on the ideal expressiveness are discussed.
Cognac: A Framework for Documenting and Verifying the Design of Cobol Systems
Cognac is presented, an extension of the Intensive tool that allows for documenting and verifying design rules in Cobol systems and a validation of the tool on an industrial, large-scale Cobol system is presented.
AOP for legacy environments, a case study
A case study where AO was applied against an industrial, legacy, non Object Oriented application, in an effort to regain lost knowledge thereof, and the implementation of an aspect language for C, aspicere, which is based on declarative pointcuts and meta information is discussed.


Language-independent aspect-oriented programming
The term aspect-oriented programming (AOP) has come to describe the set of programming mechanisms developed specifically to express crosscutting concerns, which are composed, or woven, with traditionally encapsulated functionality referred to as components.
The relevance of AOP to an Applications Programmer in an EJB environment
This paper describes a distributed system developed using EJB where crosscutting concerns were managed by the EJB environment and is an eVoting system that allows students to vote online in Student Union elections in Trinity College.
A technique for constructing aspect weavers using a program transformation engine
This paper describes the experience with using a program transformation system as the underlying engine for weaver construction and describes an initial approach for construction of language-independent aspect weavers.
Aspect-Orientated Logic Meta Programming
The principle of aspect-oriented logic meta programming and how it is useful for implementing weavers on the one hand and on the other hand allows users of aop to fine-tune, extend and adapt an aspect language to their specific needs is illustrated.
Aspect-Oriented Programming is Quantification and Obliviousness
This paper proposes that the distinguishing characteristic of Aspect-Oriented Programming (AOP) systems is that they allow programming by making quantified programmatic assertions over programs
Advice weaving in AspectJ
The 1.1 implementation which is based on transforming bytecode is described, which describes how AspectJ's join points are mapped to regions of bytecode, how these regions are efficiently matched by Aspect J's pointcuts, and how pieces of advice are efficiently implemented at these regions.
An Overview of AspectJ
AspectJ provides support for modular implementation of a range of crosscutting concerns, and simple extensions to existing Java development environments make it possible to browse the crosscutting structure of aspects in the same kind of way as one browses the inheritance structure of classes.
Static analysis of aspects
A more primitive syntax for pointcut designators, based on regular expressions, is proposed, which facilitates a new static analysis that in turn enables a more efficient implementation of aspects.
Using Dynamic Aspects to Distill Business Rules from Legacy Code
This paper advocates the use of dynamic aspects to facilitate and optimize the process of distilling business rules from legacy code and demonstrates this use through a possible scenario of investigation of a small but real life case study and concludes with the envisioned practical implementation.
Large-scale AOSD for middleware
The motivation for the research, the challenges involved, and key lessons that were learnt in refactoring both homogeneous and heterogeneous crosscutting concerns in the middleware are described.