On the declarative and procedural semantics of deductive object-oriented systems

One of the modern paradigms to develop an application is object oriented analysis and design. In this paradigm, there are several objects and each object plays some specific roles in applications. In an application, we must distinguish between procedural semantics and declarative semantics for their implementation in a specific programming language. For the procedural semantics, we can write a set of instructions that must be executed sequentially. The declarative semantics declare a set of facts and rules. They do not specify the sequence of steps for doing the processing. In this paper, we present four taxonomies for the rules in object-oriented paradigm and discuss how the paradigm can be extended to support declarative semantic of applications. Then, the rules in the taxonomies are evaluated in four case studies. After that, an approach is recommended for finding and implementation of declarative semantics, based on some practical experience obtained from the evaluation.

A formal model of analogy is introduced in the logic programming setting, and an analogical reasoning program (called DIANA, i.e. Declarative Inference by ANAlogy) is developed in accordance with precise procedural and declarative semantics. Given the source and target domains of analogy as two logic programsPs andPt, together with a specificationS of the analogical correspondence between predicate symbols, atoms involving these symbols are analogically derived fromP=Ps ∪Pt givenS, which are not derivable fromPs orPt orPs ∪Pt alone. In this paper, the requirements of the analogical process are first stated. The declarative semantics of analogy is then given, by defining the least analogical model ofP as an extension of the classical semantics of Horn clauses. A procedural semantics is also described, in terms of an extension of SLD resolution. Both semantics rely on implicit analogical axioms defining the kind of analogical reasoning envisaged. The implementation of DIANA has been done in Reflective Prolog, a metalogic programming language previously developed by the first two authors. It is shown that analogical axioms can be viewed as an instance of reflection axioms used in Reflective Prolog. By exploiting this feature, the implementation of DIANA is argued to be sound w.r.t. the defined semantics. Examples of analogical reasoning in DIANA are also described. By comparison with the AI literature on analogy, it is claimed that this is the first approach which gives a declarative semantics to analogical reasoning, thanks to the possibility of carrying over in this field the basic logic programming concepts.

Mainstream object-oriented languages often fail to provide complete powerful features altogether, such as, multiple inheritance, dynamic overloading and copy semantics of inheritance. In this paper we present a core object-oriented imperative language that integrates all these features in a formal framework. We define a static type system and a translation of the language into the meta-language λ_object, , in order to account for semantic issues and prove type safety of our proposal.

TDProlog is an extended Prolog with a term description feature. A term description is a pair of a term and a description that the term must satisfy. Declarative and procedural semantics are given. Completeness and soundness of term description is discussed.

In [3] we defined the λ&-calculus, a simple extension of the typed λ-calculus to model typed object-oriented languages. To develop a formal study of type systems for object-oriented languages we define, in this paper, a meta-language based on λ& and we show by a practical example how to use it to prove properties of a language. To this purpose we define a toy object-oriented language and its type-checking algorithm; then we translate this toy language into our meta-language. The translation gives the semantics of the toy language and a theorem on the translation of well-typed programs proves the correction of the type-checker of the toy language.As an aside we also illustrate the expressivity of the λ&-based model by showing how to translate existing features like multiple inheritance and multiple dispatch, but also by integrating in the toy language new features directly suggested by the model, such as first-class messages, a generalization of the use of super and the use of explicit coercions.KeywordsMessage PassingOperational SemanticAtomic TypeInstance VariableDynamic BindingThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

The author shows that the type inference problem for a lambda calculus with records, including a record concatenation operator, is decidable. He shows that this calculus does not have principal types but does have finite complete sets of type, that is, for any term M in the calculus, there exists an effectively generable finite set of type schemes such that every typing for M is an instance of one of the schemes in the set. The author shows how a simple model of object-oriented programming, including hidden instance variables and multiple inheritance, may be coded in this calculus. The author concludes that type inference is decidable for object-oriented programs, even with multiple inheritance and classes as first-class values.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

We present Fril++ an object-oriented extension to Fril. This new programming language supports the modelling of fuzzy applications by integrating a fuzzy logic programming language with the object-oriented paradigm. Fril++ includes the concept of fuzzy objects as an explicit construction in the language. Fuzzy objects are naturally related with multiple inheritance, and so we allow both of these in the language. The multiple inheritance gives us more flexibility, and in any case, the associated ambiguities are not so much of a problem in logic programming as they are in other paradigms. We also exploit the fact that information is expressed by the hierarchy itself. A Fril++ program can explicitly use the hierarchy by means of special constructions integrated into the language. Fril++ provides support for user decisions when there are several answers for a message by having a library of defuzzification methods.

"This book describes the aspects of mathematical logic related to computer sciences. The materials adopted in this book are intended to attend to both the peculiarities of logical systems and the requirements of computer science."

Defining the semantics of programming languages by axioms and rules of inference yields a deduction system within which proofs may be given that programs satisfy specifications. The deduction system herein is shown to be consistent and also deduction complete with respect to Hoare's system. A subgoaler for the deduction system is described whose input is a significant subset of Pascal programs plus inductive assertions. The output is a set of verification conditions or lemmas to be proved. Several non-trivial arithmetic and sorting programs have been shown to satisfy specifications by using an interactive theorem prover to automatically generate proofs of the verification conditions. Additional components for a more powerful verification system are under construction.

The problem of determining the correct declarative semantics for generalized logic programs is still open. In generalized logic programs the body of a rule may contain negated goals. Using a logical equivalence these programs may be viewed as disjunctive logic programs where the head of a rule may contain a disjunction of goals. We hope that a careful study of the declarative semantics of disjunctive logic programs will produce criteria for evaluating the different candidates for the semantics of generalized logic programs.A conceptual analysis leads to a semantical definition of the notion of a disjunctive deductive database as a generalization of the notion of a deductive database. It will be shown that the notion of a disjunctive deductive database is equivalent to the syntactical definition of a disjunctive logic program. We have characterized disjunctive deductive databases, i. e. theories which admit in each irreducible component a minimal Herbrand model and for which this property is preserved under the addition of new facts, as disjunctive logic programs. As a special case the result yields the known characterization of deductive databases, i. e. theories which admit a minimal Herbrand model and for which this property is preserved under the addition of new facts, as logic programs. In the presence of equations term structures i. e. extended Herbrand structures replace the Herbrand structures and h-core models replace the minimal models. Actually, the results could be proved in a more general context where pseudo term structures replace the term structures. In addition, there is an intermediate case where the irreducible components coincide with the connected components. Moreover, there are characterization results for the cases where the uniformity condition is not present.KeywordsLogic ProgramIrreducible ComponentTerm StructureCanonical ModelDeductive DatabaseThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

In object-oriented systems, assessing reusability plays a key role in reducing a cost and improving the quality of the software. Objectoriented programming helps in achieving the concept of reusability through different types of inheritance programs, which further help in developing reusable software modules. And object-oriented metrics identify the effectiveness of each reuse strategy. Software reusability has considerable effect on software quality. Software quality increases as reuse of software components increases. But software quality improvement cannot be understood unless it is measured. This paper focuses on an empirical evaluation of object-oriented metrics in C++ using three different object-oriented features. Three programs have been considered as input for the study -- the first program uses multilevel inheritance, the second program uses multiple inheritance and the third program uses hierarchical inheritance. We have found that multilevel inheritance has more impact on reusability among these three features.

As a first step towards an integration of Object-Oriented Programming and Declarative Programming we present a purely algebraic framework for the specification of inheritance and object hierarchies, based on the known idea of representing records as order-sorted feature terms. Specifications in our formalism have an intended semantics which can be formally characterized as an initial algebra. We argue that the new formalism improves over some shortcomings of related approaches. In particular, we can express a novel mechanism called genetic inheritance, which allows to deal with multiple inheritance in a very flexible way.

[incr Tcl], an object-oriented extension for Tcl, will be used to introduce object-oriented concepts into the Introduction to Computer Science course at the University of Northern Colorado. Tcl, an extensible, scripting language, and Tk, an extension to Tcl for building GUIs, have previously been used successfully in the same course.[incr Tcl], written in 1993 by Michael McLennan of Lucent Technologies, has encapsulation, multiple inheritance, composition, and polymorphism (via virtual methods). Tcl itself contains namespaces which extend Tcl's use to large-scale projects.The [incr Tcl] extension allows the programmer to move from Tk's object-based orientation to true object-oriented capabilities.True to Tcl/Tk, [incr Tcl] accomplishes its object-oriented ability within the same simple, command-oriented syntax. Commands like class, inherit, constructor, and protected are used.

Currently available programming and database systems are insufficient for engineering applications. The authors contend that a logical progression from a formal conceptual model of the engineering domain to a computational model will lead to new programming paradigms capable of directly supporting engineering applications in a rigorous, concise manner. A formal domain model devised by the authors, theHybrid Model (HM) of design information, is briefly introduced. It is an extension of axiomatic set theory and is discussed in detail elsewhere. HM forms the basis ofDesigner, a prototype-based object-oriented programming language supporting a signature-based canonical message-passing mechanism and multiple inheritance. Designer is implemented using the Scheme programming language. Because Designer satisfies a formal conceptual model, and because it is based on a formally specified language, its robustness and logical validity are superior to those of other languages not founded on formal principles. Designer combines concepts of functional and object-oriented programming to provide the formal rigor and flexibility to capture the complex and strongly interrelated information that designers use. Examples demonstrate how Designer represents design information. The results of the authors' research indicate that Designer can capture design information (including aspects of functional requirements and design intent) effectively and efficiently.

Object-oriented languages with multiple inheritance and automatic conflict resolution typically use a linearization of superclasses to determine which version of a property to inherit when several superclasses provide definitions. Recent work has defined several desirable characteristics for linearizations, the most important being monotonicity, which prohibits inherited properties from skipping over direct superclasses. Combined with Dylan's sealing mechanism, a monotonic linearization enables some compile-time method selection that would otherwise be impossible in the absence of a closed-world assumption.The Dylan linearization is monotonic, easily described, strictly observes local precedence order, and produces the same ordering as CLOS when that is monotonic. We present an implementation based on merging and a survey of class heterarchies from several large programs, analyzing where commonly used linearizations differ.