Non‐intrusive object introspection in C++

We describe the design and implementation of system architecture to support object introspection in C++. In this system, information is collected by parsing class declarations, and is used to build a supporting environment for object introspection. Our approach is non‐intrusive because it requires no changes in the original class declarations and libraries; hence, binary compatibility between objects before and after the addition of introspective capability is ensured. This is critical if one wants to integrate third‐party class libraries, which are often supplied as black boxes and allow no modification, into highly dynamic applications. We present two applications: the first is automatic I/O support for C++ objects, and the other is interactive exercise of dynamically loaded C++ class libraries. Copyright © 2001 John Wiley & Sons, Ltd.     

GLU♮ embedded in C++: a marriage between multidimensional and object‐oriented programming

The embedding of a small but expressive language of multidimensional functional programming in a well known and widely used language of object‐oriented programming leads to the combination of two radically different programming models. In this paper, we formally define the syntax and semantics of GLU^?, which can be thought of as the multidimensional core of Lucid and GLU, and we describe its implementation as a language embedded in C++. With the aid of a few examples, we argue that the marriage of the two programming models is not only compatible and natural, but also that it produces a new and interesting hybrid language. Copyright © 2004 John Wiley & Sons, Ltd.     

FC++: Functional tools for object‐oriented tasks

FC++ is a library for programming functionally in C++. Compared to other C++ functional programming libraries, FC++ is distinguished by its powerful type system which allows the manipulation of parametrically polymorphic functions (e.g., passing them as arguments to other functions and returning them as results). In this paper, we show how FC++ can be used in common object‐oriented programming tasks. We demonstrate FC++ implementations of several common design patterns (Adapter, Builder, Command, and more). Compared to conventional C++ implementations of these patterns, our implementations are either simpler (in that fewer classes/dependencies are needed), more efficient, or more type‐safe (thanks to parametric polymorphism and type inference). Copyright © 2002 John Wiley & Sons, Ltd.     

Modularizing application and database evolution – an aspect‐oriented framework for orthogonal persistence

In the maintenance of software applications, database evolution is one common difficulty. In object‐oriented databases, this process comprises schema evolution and instance adaptation. Both tasks usually require significant effort from programmers and database administrators. In this paper, we propose orthogonal persistence and aspect‐oriented programming to support semi‐transparent database evolution. A default mechanism for instance evolution is defined, but the user may provide modularized solutions using the aspect‐oriented paradigm. We present our framework AOF4OOP to test the feasibility of our proposed approach. This prototype allows programmes to transparently access data in other versions of the database schema. We evaluate our framework, comparing it to related approaches using two real applications and measuring the improvement of the productivity of the programmer. Copyright © 2016 John Wiley & Sons, Ltd.     

Interpreting computer code in a computer‐based learning system for novice programmers

Although the principles of writing compilers and interpreters are well known, we have found that the ideas needed to develop an interpreter for the express purpose of allowing direct interaction with the running code do not yet appear to have been published in an academic context. We describe a programming method that can be used for the production of an interpreter for common object‐oriented languages such as C++, Java and C#. The main purpose of the interpreter is to parse short, relatively simple programs and allow direct interaction between the user and the running code. Such a system is useful for projects such as OGRE, which is an educational tool allowing students to visualize in three‐dimensional graphics the state of a program as it runs. The interpreter works by first parsing the source code and building up a data structure capable of representing the program's source code in a form that can be used to both run the program and extract detailed information from the running program. This extraction allows for novel uses of the interpreter, such as forming the basis for a visualization system that must display and provide such information to the user as they watch their executing program. This paper considers the construction of such an interpreter specifically for C++, but the principles should be the same for other similar languages such as Java and C#. We cover the main tasks required of the programmer to create and use the data structure, highlighting areas such as its design, initial construction during parsing, and techniques required to use it for interpretation. These include the ability for the data structure to intelligently clone subsets of itself when multiple copies of one of its elements are required by the running program, how it handles C++'s complicated function overloading and overriding rules, and how inheritance and polymorphism can be supported. Copyright © 2005 John Wiley & Sons, Ltd.     

Implementation of a TMO‐structured real‐time airplane‐landing simulator on a distributed computing environment

In real‐time simulation, the simulated system should display the same (or very close) timing behavior as the target system. The simulation accuracy is increased as the simulation time unit is decreased. Although there are several models for such systems, the TMO model is particularly appropriate due to its natural support for real‐time distributed object‐oriented programming. This paper discusses the results of the implementation of a real‐time airplane‐landing simulator on a distributed computing environment using the TMO model. Copyright © 2004 John Wiley & Sons, Ltd.     

Productivity analysis of object‐oriented software developed in a commercial environment

The introduction of object‐oriented technology does not appear to hinder overall productivity on new large commercial projects, but nor does it seem to improve it in the first two product generations. In practice, the governing influence may be the business workflow, and not the methodology. Copyright © 1999 John Wiley & Sons, Ltd.     

Developing an object‐oriented framework for content‐based image retrieval

Content‐based image retrieval (CBIR) is a process of retrieving images from an image database by exploiting the content of the images (typically the querying of an image). CBIR avoids many problems associated with traditional ways of retrieving images by keywords. Thus, a growing interest in the area of CBIR has been established in recent years. In this paper, a novel object‐oriented framework (CBIRFrame) is built for CBIR applications development. We discuss the motivations for CBIRFrame before discussing its design in detail. Two applications of CBIRFrame are also briefly discussed to show the effectiveness of applying CBIRFrame to real applications. Finally, we outline the possible uses of the design of CBIRFrame for other types of domains, such as content‐based retrieval of video clips. Copyright © 2003 John Wiley & Sons, Ltd.     

An enhanced role model for alleviating the role‐binding anomaly

Roles and role models have received much attention as useful concepts for developing highly reusable and dynamically evolvable systems. Role models belong to the category of collaboration‐based development techniques, but most of the existing approaches to role models do not explicitly incorporate the core principle of collaboration‐based developments as an essential property of their primary design goals. Consequently, the existing approaches still suffer from a problematic phenomenon that the structural and behavioral constraints defined in a role system can be violated during the role‐binding stage. We call such a problematic phenomenon the role‐binding anomaly. In order to alleviate the role‐binding anomaly, we propose an enhanced role model, in which all role instances and core objects can exist by themselves, namely, they can be developed, executed, and tested independently. Roles and core classes can be bound to each other at the instance level. In addition, the role system describes and encapsulates the behavior for dynamic reconfigurations among role instances. The enhanced role model is designed so as to be meaningful with respect to software engineering principles, rather than dynamic evolution. It also facilitates role model implementation using general programming languages (i.e. not supporting dynamic specialization) such as Java. To illustrate how the proposed role model makes such benefits, we develop a set of Java classes necessary for implementing the enhanced role model in the form of a Java package role, and present a simplified automatic teller machine system as an example application. Copyright © 2002 John Wiley & Sons, Ltd.     

Investigating the use of analysis contracts to improve the testability of object‐oriented code

A number of activities involved in testing software are known to be difficult and time consuming. Among them is the definition and coding of test oracles and the isolation of faults once failures have been detected. Through a thorough and rigorous empirical study, we investigate how the instrumentation of contracts could address both issues. Contracts are known to be a useful technique in specifying the precondition and postcondition of operations and class invariants, thus making the definition of object‐oriented analysis or design elements more precise. It is one of the reasons the Object Constraint Language (OCL) was made part of the Unified Modeling Language. Our aim in this paper is to reuse and instrument contracts to ease testing. A thorough case study is run where we define OCL contracts, instrument them using a commercial tool and assess the benefits and limitations of doing so to support the automated detection of failures and the isolation of faults. As contracts can be defined at various levels of detail, we also investigate the cost and benefit of using contracts at different levels of precision. We then draw practical conclusions regarding the applicability of the approach and its limitations. Copyright © 2003 John Wiley & Sons, Ltd.     

Object‐process based graphics recognition class library: principles and applications

We have developed a Graphics Class Library (GCL) for graphics recognition using the object‐process methodology and object‐oriented implementation. The purpose of the library is to supply generic code for graphics recognition algorithms to be used as ready made and easily extendible components in future systems. The library consists of reusable classes of graphic objects that appear in engineering drawings as well as in other classes of line drawings. A generic integrated graphics recognition algorithm is at the basis of the library, serving useful standard operations required for graphics recognition applications. Copyright © 1999 John Wiley & Sons, Ltd.     

Managing change in an information systems development organization: understanding developer transitions from a structured to an object‐oriented development environment1

Abstract. Object‐oriented systems development has attracted great interest in the information systems (IS) field because of a belief that using object‐oriented development (OD) makes it easier to develop and maintain software plus achieve software reuse. However, the transition from structured to OD may be especially challenging for IS developers. In fact, some argue that structured development (SD) knowledge may interfere with the ability to learn OD approaches because of a form of proactive interference. To understand how knowledge of SD concepts influences the ability to gain OD knowledge, we assessed a team of IS developers' understanding of structured and object‐oriented concepts at the beginning of their first OD project and repeated our assessment 1 year later. Developers increased their understanding of some object‐oriented concepts, but these changes were associated with increases in understanding of one of the SD concepts. Further, at the beginning and end of the project, developers' mental models were highly consistent with one another and that of an OD expert with regard to most OD concepts. It appears that the formal training that developers received allowed them to attain a good understanding of most object‐oriented concepts. These findings challenge the idea that structured developers must ‘unlearn’ SD to adopt OD approaches. Future research may wish to examine the different types of software development knowledge to ascertain which are amenable to positive transfer and which are more likely to suffer from proactive interference.     

From genetic to bacteriological algorithms for mutation‐based testing

The level of confidence in a software component is often linked to the quality of its test cases. This quality can in turn be evaluated with mutation analysis: faults are injected into the software component (making mutants of it) to check the proportion of mutants detected (‘killed’) by the test cases. But while the generation of a set of basic test cases is easy, improving its quality may require prohibitive effort. This paper focuses on the issue of automating the test optimization. The application of genetic algorithms would appear to be an interesting way of tackling it. The optimization problem is modelled as follows: a test case can be considered as a predator while a mutant program is analogous to a prey. The aim of the selection process is to generate test cases able to kill as many mutants as possible, starting from an initial set of predators, which is the test cases set provided by the programmer. To overcome disappointing experimentation results, on .Net components and unit Eiffel classes, a slight variation on this idea is studied, no longer at the ‘animal’ level (lions killing zebras, say) but at the bacteriological level. The bacteriological level indeed better reflects the test case optimization issue: it mainly differs from the genetic one by the introduction of a memorization function and the suppression of the crossover operator. The purpose of this paper is to explain how the genetic algorithms have been adapted to fit with the issue of test optimization. The resulting algorithm differs so much from genetic algorithms that it has been given another name: bacteriological algorithm. Copyright © 2005 John Wiley & Sons, Ltd.     

The Object‐JavaScript language

Complex graphical user interfaces (GUIs) that support a large amount of user interaction require a fast response time, a rich set of building blocks for an esthetic look‐and‐feel, and a development environment that supports ongoing change. On the World Wide Web, client‐side technologies offer more of these features than do server‐side solutions. Java and JavaScript are the two most popular languages used for client‐side GUI implementations. Java implementations require a user to download a plug‐in that contains a virtual machine to execute the Java byte‐code. The installation and maintenance of this plug‐in is sometimes an unsurmountable barrier to using Java. JavaScript lacks some of the desirable features of Java, such as easy to use object‐oriented features and having a GUI class library, but does not require a plug‐in. We have enhanced JavaScript by implementing a new language Object‐JavaScript (OJS) and by providing an OJS library of GUI components, thus making it a viable alternative to Java. Copyright © 2000 John Wiley & Sons, Ltd.     

Double dispatch in C++

Double dispatch is the ability to dynamically select a method not only according to the run‐time type of the receiver (single dispatch), but also according to the run‐time type of the argument. This mechanism unleashes the power of dynamic binding in object‐oriented languages, so enhancing re‐usability and separation of responsibilities. However, many mainstream languages, such as, e.g., C++ and Java, do not provide it, resorting only to single dispatch. In this paper we propose an extension of C++ (also applicable to other object‐oriented languages) that enables double dispatch as a language feature. This yields dynamic overloading and covariant specialization of methods. We define a translation from the new constructs to standard C++ and we present the preprocessor implementing this translation, called doublecpp . The translated code enjoys static type safety and implements the semantics of double dispatch by using only standard mechanisms of static overloading and dynamic binding, with minimal impact on the performance of the program. Copyright © 2006 John Wiley & Sons, Ltd.     

Agents in object‐oriented software engineering

Software engineers of multi‐agent systems (MASs) are faced with different concerns such as autonomy, adaptation, interaction, collaboration, learning, and mobility, which are essentially different from classical concerns addressed in object‐oriented software engineering. MAS developers, however, have relied mostly on object‐oriented design techniques and programming languages, such as Java. This often leads to a poor separation of MAS concerns and in turn to the production of MASs that are difficult to maintain and reuse. This paper discusses software engineering approaches for MASs, and presents a new method for integrating agents into object‐oriented software engineering from an early stage of design. The proposed approach encourages the separate handling of MAS concerns, and provides a disciplined scheme for their composition. Our proposal explores the benefits of aspect‐oriented software development for the incorporation of agents into object‐oriented systems. We also illustrate our aspect‐oriented approach through the Portalware multi‐agent system, a Web‐based environment for the development of e‐commerce portals. Copyright © 2004 John Wiley & Sons, Ltd.     

基于嵌入式操作系统的面向方面编程的研究

从传统的面向对象编程的局限性入手，提出面向方面编程，阐述了该编程思想的优越性并分析它和设计模式之间的关系。最后简单介绍了嵌入式操作系统，提出面向方面编程思想在其上的应用。     

A case study in mapping conceptual designs to object‐relational schemas

The recent emergence of object‐relational technology into the commercial database market has caused new challenges for the implementation of conceptual database designs. This paper presents our experience with using the Oracle 8 object‐relational data model in the implementation of an engineering application described using the EXPRESS conceptual modeling language. EXPRESS is part of the engineering community's Standard for the Exchange of Product Data and can be characterized as a structurally object‐oriented modeling language, supporting the notion of entities, entity hierarchies, complex constraints on entity hierarchies, relationships and inverse relationships between entities, and user‐defined types. As a result, EXPRESS provides an excellent framework for studying the mapping of conceptual modeling concepts into an object‐relational model. In this paper, we describe the way in which the features of EXPRESS can be mapped into object‐relational features such as object tables, object references, and nested tables. We also describe the manner in which features such as member functions on object types, triggers, and stored procedures can be used to support the implementation of constraints associated with a conceptual schema. Although the mappings presented are specific to EXPRESS and Oracle 8, the mappings are generalizable to conceptual modeling languages and object‐relational models with similar features. Our work defines how traditional mapping concepts must be revised in order to make adequate use of the features now found in object‐relational models. As part of this paper, we also compare our mapping approach using Oracle 8 to mapping issues for the PostgreSQL object‐relational model and the Objectivity/DB object‐oriented data model. Copyright © 2000 John Wiley & Sons, Ltd.     

可信操作系统中可信客体的研究

分析了操作系统中客体的类型,将客体分为静态客体和动态客体,然后总结了安全操作系统中对客体的处理存在的问题。在此基础路上,提出可信静态客体、可信动态客体和可信客体的概念,并分析了可信客体的特点以及与安全客体的关系。最后提出了在可信操作系统客体的可信需求。为下一步将要开展的工作奠定基础。