Content uploaded by Hideaki Shinomi
Author content
All content in this area was uploaded by Hideaki Shinomi on Feb 03, 2014
Content may be subject to copyright.
A preview of the PDF is not available
Program Analysis Environment for Writing COBOL Aspects
Abstract and Figures
COBOL is still an important language for building mission critical enterprise systems, and there is huge amount of existing COBOL programs. We have been developing an aspect-oriented COBOL and its development environment. We are applying aspect orientation to strengthening internal control in enterprise information systems. Understanding existing COBOL programs is critical for applying aspect orientation to them, because programmers are not able to write aspects without understanding the existing programs. We have developed an environment for understanding existing COBOL programs and developing COBOL aspects. This paper describes the environment and a experience of applying it to improve internal control implemented in a small information system.
Figures - uploaded by Hideaki Shinomi
Author content
All figure content in this area was uploaded by Hideaki Shinomi
Content may be subject to copyright.
Supplementary resource (1)
... In this regard Altair environment was used for understanding and developing programs for aspectoriented Cobol [23].The researchers claim that aspect orientation can be applied to strengthen the internal control of existing Cobol programs. Cobol companies worldwide are also making their information systems comply with the new standards and requirements such as the SOX like laws [23] [22].The additional features that needs to be implemented for this compliance are when implemented using aspects results in better modularization and separation of concerns. 2The business rules staying as it is in the base code and the additional features being implemented using thee aspects. ...
Many organizations suffer from superfluous, disproportionate, difficult-to-extend software because of the lack in maintenance effort and ignoring the fact that continuous refactoring provides a competitive advantage. Refactoring is assumed to positively affect the software parameters like scalability, modularity, reusability, complexity, maintainability, performance and efficiency. Several refactoring have been proposed for object-oriented languages, but there are few related works focusing on procedural programming. In this paper, an assessment is provided of selected literatures which relate to refactoring of procedural languages, and it also contributes to highlighting new concepts and requirements for developing new refactoring techniques for C that may eventually benefit other procedural languages also .To this end, we have studied the refactorings performed on 3 procedural languages that are Fortran, Cobol and C to analyze the pattern of refactorings followed in these languages and assess their cumulative effect in different applications. We offer a few refactoring capabilities that may improve the existing refactorings for these languages by our contribution to refactoring that characterizes of a new aspect oriented programming style.
An aspect-oriented program consists of aspects and a base program into which the aspects are woven. Usually, the base programs work even without the aspects being woven into them. Many of the base programs are existing programs, and test cases have already been prepared for them. In those cases, it is useful for programmers to grasp the impact of the weaving of aspects into the base program. For example, an impact analysis is effective for problem determination of the defects inserted by the weaving, and for determination of the scope of the regression tests after the weaving. The authors propose an analysis method for the potential impacts on a base program from aspect weaving [6]. In this demonstration, we present our tool for impact analysis of weaving, which was implemented on Eclipse. The results of the analysis are shown on an editor that was developed as an extension of the AspectJ Development Tools (AJDT) editor. As the basis of the tool, we designed and implemented a Eclipse-based platform for analyzing Java and AspectJ programs. The platform was named JADE (Java and Aspectj DEpendence analyzer). JADE allows eclipse-based tool developers to create program analysis tools based on system dependence graphs.
Aspect-Oriented Programming (AOP) introduces a new software module unit named aspect to encapsulate crosscutting concerns. While AOP modularizes crosscutting concerns to improve maintainability and reusability, AOP introduces a new factor of complexity. It is difficult to find defects caused by an aspect modifying or preventing the behavior of other objects and aspects. In this paper, we examine a method to support a debugging task in aspect-oriented software development. We propose an application of a call graph generation and program slicing to assist in debugging. A call graph visualizes control dependence relations between objects and aspects and supports the detection of an infinite loop. On the other hand, program slicing shows the user changes of dependence relations caused by aspects. We implement a program-slicing tool for AspectJ and apply it to certain programs. The experiment illustrates how our approach effectively helps developers understand the influence of aspects in a program.
Cobol is still a vitally important language for mission-critical enterprise systems, and so much effort is being spent on system development projects involving Cobol applications. In order to ease these tasks with the Aspect-Oriented Programming technology, we have developed a version of Aspect-Oriented Cobol, which constitutes the core of a system enhancement service being offered for real-world customers.
We report on ALCOB, our aspect-description language, and its weaving semantics. We have also implemented an industry-strength weaver for ALCOB. We describe the business rationales in our endeavour which gave rise to a set of clear design principles.
We have found many programming problems for which neither procedural nor object-oriented programming techniques are sufficient to clearly capture some of the important design decisions the program must implement. This forces the implementation of those design decisions to be scattered throughout the code, resulting in “tangled” code that is excessively difficult to develop and maintain. We present an analysis of why certain design decisions have been so difficult to clearly capture in actual code. We call the properties these decisions address aspects, and show that the reason they have been hard to capture is that they cross-cut the system's basic functionality. We present the basis for a new programming technique, called aspect-oriented programming, that makes it possible to clearly express programs involving such aspects, including appropriate isolation, composition and reuse of the aspect code. The discussion is rooted in systems we have built using aspect-oriented programming.
Program slicing is a method for automatically decomposing programs by analyzing their data flow and control flow. Starting from a subset of a program's behavior, slicing reduces that program to a minimal form which still produces that behavior. The reduced program, called a ``slice,'' is an independent program guaranteed to represent faithfully the original program within the domain of the specified subset of behavior. Some properties of slices are presented. In particular, finding statement-minimal slices is in general unsolvable, but using data flow analysis is sufficient to find approximate slices. Potential applications include automatic slicing tools for debuggng and parallel processing of slices.