Property Based Dynamic Slicing of Object Oriented Programs

Santosh Kumar Pani; G.B. Mund

doi:10.11591/ijset.v1i2.4570

Property Based Dynamic Slicing of Object Oriented Programs

International Journal of Software Engineering and Technologies (IJSET) ◽

10.11591/ijset.v1i2.4570 ◽

2016 ◽

Vol 1 (2) ◽

pp. 69

Author(s):

Santosh Kumar Pani ◽

G.B. Mund

Keyword(s):

Program Analysis ◽

Object Oriented ◽

Object Oriented Programming ◽

Intermediate Representation ◽

Interactive Applications ◽

Dynamic Slicing ◽

Concrete Properties ◽

Execution Trace ◽

Class Definition ◽

Basic Features

Slicing is used for program analysis. It the process of extracting the statements of a program that are relevant to a given computation. Static slicing generates slices for all possible execution of a program helping in program understanding, verification, maintenance and testing. Dynamic slices are smaller in size as they extract slices for a given execution of a program and helps in interactive applications like debugging and testing. With the wide spread use of object oriented software, there are many papers on Dynamic Slicing of object oriented programs but few papers only address in details about the most basic features of Object Oriented Programming that is class definition, Object creation, accessing object through reference, invoking methods of a class , polymorphism, inheritance etc. From last three decades many algorithms have been designed to slice a program with respect to the syntax of the program. The real world object oriented programs consists of thousands of lines of code. Traditional Syntax based slices for program variables used at many places in a program are generally large even for dynamic slices. Recently, some work has been done to get slices based on abstract/concrete properties of program variables. For smooth debugging and testing, the slice will be small if any particular property is being considered (semantics based). Most of the semantics based slicing algorithms have focused on finding static slices on the abstract properties by using SSA as intermediate representation and extract slices by storing an execution trace of a program. To the best of our knowledge generating dynamic slices based on abstract/Concrete properties of program variables is scarcely reported in literature. In this paper we present an algorithm for generating dynamic abstract slices of object oriented programs addressing all key object oriented features.

Download Full-text

A paradigmatic object-oriented programming language: Design, static typing and semantics

Journal of Functional Programming ◽

10.1017/s0956796800001039 ◽

1994 ◽

Vol 4 (2) ◽

pp. 127-206 ◽

Cited By ~ 68

Author(s):

Kim B. Bruce

Keyword(s):

Fixed Points ◽

Programming Languages ◽

Programming Language ◽

Type System ◽

Object Oriented ◽

Object Oriented Programming ◽

Language Design ◽

Type Checking ◽

Basic Features ◽

Oriented Programming Language

AbstractTo illuminate the fundamental concepts involved in object-oriented programming languages, we describe the design of TOOPL, a paradigmatic, statically-typed, functional, object-oriented programming language which supports classes, objects, methods, hidden instance variables, subtypes and inheritance.It has proven to be quite difficult to design such a language which has a secure type system. A particular problem with statically type checking object-oriented languages is designing typechecking rules which ensure that methods provided in a superclass will continue to be type correct when inherited in a subclass. The type-checking rules for TOOPL have this feature, enabling library suppliers to provide only the interfaces of classes with actual executable code, while still allowing users to safely create subclasses. To achieve greater expressibility while retaining type-safety, we choose to separate the inheritance and subtyping hierarchy in the language.The design of TOOPL has been guided by an analysis of the semantics of the language, which is given in terms of a model of the F-bounded second-order lambda calculus with fixed points at both the element and type level. This semantics supports the language design by providing a means to prove that the type-checking rules are sound, thus guaranteeing that the language is type-safe.While the semantics of our language is rather complex, involving fixed points at both the element and type level, we believe that this reflects the inherent complexity of the basic features of object-oriented programming languages. Particularly complex features include the implicit recursion inherent in the use of the keyword, self, to refer to the current object, and its corresponding type, MyType. The notions of subclass and inheritance introduce the greatest semantic complexities, whereas the notion of subtype is more straightforward to deal with. Our semantic investigations lead us to recommend caution in the use of inheritance, since small changes to method definitions in subclasses can result in major changes to the meanings of the other methods of the class.

Download Full-text

Object-Oriented Programming and Representation of Objects

Studies in Logic, Grammar and Rhetoric ◽

10.1515/slgr-2015-0014 ◽

2015 ◽

Vol 40 (1) ◽

pp. 293-302

Author(s):

Adam Drozdek

Keyword(s):

Object Oriented ◽

Object Oriented Programming ◽

Class Definition ◽

The Way

Abstract In this paper, a lesson is drawn from the way class definitions are provided in object-oriented programming. The distinction is introduced between the visible structure given in a class definition and the hidden structure, and then possible connections are indicated between these two structures and the structure of an entity modeled by the class definition.

Download Full-text

Name Collision in Multiple Classification Hierarchies

DAIMI Report Series ◽

10.7146/dpb.v17i250.7606 ◽

1988 ◽

Vol 17 (250) ◽

Author(s):

Jørgen Lindskov Knudsen

Keyword(s):

Programming Languages ◽

Object Oriented ◽

Object Oriented Programming ◽

Multiple Classification ◽

Multiple Paths ◽

Class Definition

Supporting multiple classification in object-oriented programming languages is the topic of discussion in this paper. Supporting multiple classification gives rise to one important question --- namely the question of inheritance of attributes with identical names from multiple paths in the classification hierarchy. The problem is to decide how these multiple classification paths are reflected in the class being defined. One of the conclusions in this paper is, that by choosing strict and simple inheritance rules, one is excluding some particular usages of multiple classification. This leads to the notion of attribute-resolution at class definition, which means that the programmer in some cases is forced or allowed to resolve the potential ambiguity of the inherited names. The concept of attribute-resolution is managed through the identification of two conceptually different utilizations of specialization (unification and intersection), and two different attribute properties (plural and singleton) to guide the attribute-resolution.

Download Full-text