Embed finite domain constraint programming into Java and some Web‐based applications

Although constraint programming has attracted much attention in logic programming, nowadays the importance to integrate constraints with imperative programming is widely acknowledged. In particular, in artificial intelligence domains, the benefits deriving from merging constraint‐based programming with object‐oriented paradigms seem to be still more attractive because of the lack of ‘pure’ AI languages in supporting structured representations. This work presents the extension of the Java language towards finite domain constraint programming. This extension has been possible thanks to a high‐level approach to low‐level resource management: the sleeper mechanism. As practical results, this paper shows how Java programmers can develop meaningful applications in which finite domain constraints have been extensively used, as in the design of visual, interactive, user‐interface environments in a client–server architecture. Copyright © 1999 John Wiley & Sons, Ltd.     

BCOOPL: A Language for Controlling Component Interactions

This paper introduces BCOOPL, which stands for Basic Concurrent Object-Oriented Programming Language. BCOOPL was designed to support component-based development. In particular, it focuses on the specification of weakly-coupled components and the specification of interaction sequences between them. BCOOPL supports two design patterns directly. The built-in observer design pattern encourages the construction of weakly-coupled components. Its support for the mediator design pattern allows to govern the interactions between those components. These language features cater for the design and implementation of flexible systems in which specifications of individual component behavior is separated from specifications of component interactions. A high level overview of BCOOPL's key concepts is given, which are exemplified by means of a process control example.     

Parallel programming with logic languages: A survey

Formal properties of logic languages are largely studied; however, their impact on the practice of software design and programming is currently minimal. In this paper we survey some interesting representatives of the family of logic languages aiming at comparing the different capabilities they offer for designing and programming parallel systems. The logic languages Prolog, Aurora, Flat Concurrent Prolog, Parlog, GHC, and DeltaProlog were chosen, because a suitable set of relevant examples has been published, mostly by the language designers themselves. A number of sample programs is used to expose and compare the languages with respect to their object oriented programming capabilities for multiprocess coordination, interprocess communication, and resource management. Special attention is devoted also to metaprogramming as well, seen as a useful technique for specifying and building the operating environments of the languages themselves. The paper ends with a discussion on positive and negative features found comparing these languages, and indicates some guidelines to be followed in the design of new logic languages.     

Quantifying and evaluating the space overhead for alternative C++ memory layouts

This paper develops a formalism that precisely characterizes when class tables are required for C++ memory layouts. A memory layout is a particular choice of data structures for implementing run‐time support for object‐oriented languages. We use this formalism to quantify and evaluate, on a set of benchmarks, the space overhead for a set of C++ memory layouts. In particular, this paper studies the space overhead due to three language features: virtual dispatch, virtual inheritance, and dynamic typing. To date, there has been no scientific quantification or evaluation of C++ memory layouts. Our approach can help C++ implementors. This work has already influenced the memory layout design choices in IBM's Visual Age C++ V5 compiler. Applying our approach to a set of five benchmarks, we demonstrate that the impact of object‐oriented space overhead can vary dramatically between applications (ranging from 0.42% to 99.79% for our benchmarks). In particular, applications whose object space is dominated by instances of classes that heavily use object‐oriented language features will be significantly impacted by the choice of a memory layout. Copyright © 2003 John Wiley & Sons, Ltd.     

Using roles in Java

Using roles in object‐oriented design leads to a more natural representation of a given problem domain. Despite a lot of research into role–based systems, there is still a gap between conceptual representations of roles and the usage of roles in strongly typed object‐oriented programming languages such as C++ or Java. Since these languages associate classes and their instances exclusively and permanently, representing evolving objects that may take on different roles over time is difficult without special support: (i) entities must be reclassified any time they evolve and (ii) class hierarchies may grow exponentially if entities may take on several independent roles. This article shows how role hierarchies can be easily implemented in Java. It introduces the Java Role Package, which provides a set of classes to support handling of evolving objects without modifying the semantics of Java itself. Copyright © 2004 John Wiley & Sons, Ltd.     

Intelligent Fril/SQL interrogator

The intelligent Fril/SQL interrogator is an object‐oriented and knowledge‐based support query system, which is implemented by the set of logic objects linking one another. These logic objects integrate SQL query, support logic programming language—Fril and Fril query together by processing them in sequence in slots of each logic object. This approach therefore takes advantage of both object‐oriented system and a logic programming‐based system. Fuzzy logic data mining and a machine learning tool kit built in the intelligent interrogator can automatically provide a knowledge base or rules to assist a human to analyze huge data sets or create intelligent controllers. Alternatively, users can write or edit the knowledge base or rules according to their requirements, so that the intelligent interrogator is also a support logic programming environment where users can write and run various Fril programs through these logic objects. © 2007 Wiley Periodicals, Inc. Int J Int Syst 22: 279–302, 2007.     

A survey of concurrent object‐oriented languages

During the last decade object‐oriented programming has grown from marginal influence into widespread acceptance. During the same period, progress in hardware and networking has changed the computing environment from sequential to parallel. Multi‐processor workstations and clusters are now quite common. Unnumbered proposals have been made to combine both developments. Always the prime objective has been to provide the advantages of object‐oriented software design at the increased power of parallel machines. However, combining both concepts has proven to be notoriously difficult. Depending on the approach, often key characteristics of either the object‐oriented paradigm or key performance factors of parallelism are sacrificed, resulting in unsatisfactory languages. This survey first recapitulates well‐known characteristics of both the object‐oriented paradigm and parallel programming, and then marks out the design space of possible combinations by identifying various interdependencies of key concepts. The design space is then filled with data points: for 111 proposed languages we provide brief characteristics and feature tables. Feature tables, the comprehensive bibliography, and web‐addresses might help in identifying open questions and preventing re‐inventions. Copyright © 2000 John Wiley & Sons, Ltd.     

Ontology oriented programming in go!

In this paper we introduce the knowledge representation features of a new multi-paradigm programming language called go! that cleanly integrates logic, functional, object oriented and imperative programming styles. Borrowing from L&O [1] go! allows knowledge to be represented as a set of labeled theories incrementally constructed using multiple-inheritance. The theory label is a constructor for instances of the class. The instances are go!’s objects. A go! theory structure can be used to characterize any knowledge domain. In particular, it can be used to describe classes of things, such as people, students, etc., their subclass relationships and characteristics of their key properties. That is, it can be used to represent an ontology. For each ontology class we give a type definition—we declare what properties, with what value type, instances of the class have—and we give a labeled theory that defines these properties. Subclass relationships are reflected using both type and theory inheritance rules. Following [2], we shall call this ontology oriented programming. This paper describes the go! language and its use for ontology oriented programming, comparing its expressiveness with Owl, particularly Owl Lite[3]. The paper assumes some familiarity with ontology specification using Owl like languages and with logic and object oriented programming.     

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.     

基于VC++环境的ComGIS开发初探

ComGIS也称组件式地理信息系统,是指由一组遵循COM(组件对象模型)“工业标准”的,基于组件对象平台的,允许跨语言应用甚至跨计算机交互的组件提供的GIS,各GIS组件之间可通过标准的通信接口实现互操作,目前它已经成为地理信息系统软件发展的新潮流。VisualC++简称VC,是微软公司推出的一个面向对象的、功能丰富的可视化重量级的开发工具。在目前流行的VisualC++,VisualBasic,Delphi等众多开发工具中,其功能最为强大。但目前对于在VC++环境下如何开发组件式地理信息系统的研究却很少。该文以VC++6.0开发环境和MapObjects2.0为例,采用西北干旱区典型的内陆河石羊河流域的地图数据,探讨了在VC++环境中地理信息系统组件的嵌入、地理信息系统基本功能如图形的放大、漫游以及图形显示的恢复等基本问题,进而为开发基于VC++环境的组件式地理信息系统提供参考和依据。     

传统程序设计语言的面向对象扩充的若干技术

本文论述用转换方式实现传统程序设计语言的面向对象扩充，给出了一组关键技术以解决由子类型多态和动态定连所引出的问题，其基本思想是将类和对象类型分开处理，从而避免转换过程中的重复工作．这些技术具有适用性强、功效高的特点，并且在ＰＡＳＣＡＬ语言的面向对象扩充ＮＤＯＯＰ和ＭＯＤＵＬＡ－２语言的面向对象扩充ＮＤＯＯＭ的实现中被采用，效果令人满意.     

The Synchronous Approach to Designing Reactive Systems

Synchronous programming is available through several formally defined languages having very different characteristics: Esterel is imperative, while Lustre and Signal are declarative in style; Statecharts and Argos are graphical languages that allow one to program by constructing hierarchical automata. Our motivation for taking the synchronous design paradigm further, integrating imperative, declarative (or dataflow), and graphical programming styles, is that real systems typically have components that match each of these profiles. This paper motivates our interest in the mixed language programming of embedded software around a number of examples, and sketches the semantical foundation of the Synchronie toolset which ensures a coherent computational model. This toolset supports a design trajectory that incorporates rapid prototyping and systematic testing for early design validation, an object oriented development methodology for long term software management, and formal verification at the level of automatically generated object code.     

并发面向对象程序设计语言研究与进展

随着面向对象程序设计的普及和对并发应用程序需求的增加，并发面向对象程序设计语言的设计日益成为研究热点。     

Mirror‐based reflection in AmbientTalk

This paper introduces a novel mechanism to perform intercession (a form of reflection) in an object‐oriented programming language with the goal of making the language extensible from within itself. The proposed mechanism builds upon a mirror‐based architecture, leading to a reusable reflective application programming interface that cleanly separates interface from implementation details. However, support for intercession has been limited in contemporary mirror‐based architectures. This is due to the fact that mirror‐based architectures only support reflection explicitly triggered by metaprograms, while intercession requires reflection implicitly triggered by the language interpreter. This work reconciles mirrors with intercession in the context of an actor‐based, object‐oriented programming language named AmbientTalk. We describe this language's full reflective architecture, highlighting its novel mirror‐based approach to reflect upon both objects and concurrently executing actors. Subsequently, we apply AmbientTalk's mirror‐based reflection to implement two language features, which crucially depend on intercession, to wit future‐type message passing and leased object references. Copyright © 2008 John Wiley & Sons, Ltd.     

软件Agent的一种面向对象设计模型

怎样实现软件Agent是设计与开发面向Agent编程语言及工具的关键问题.为基于当前主流的面向对象技术来解决该问题,首先讨论了对象与Agent的主要区别,然后通过对Agent的BDI模型进行简化改进,提出了一种基于对象技术的软件Agent的实现体系结构及其内部行为自主决策算法.最后,基于该结构及算法并利用设计模式开发出了软件Agent的一种面向对象设计框架.该工作对于上述问题的解决,以及在现有成熟的面向对象技术基础上开发出软件Agent程序设计语言及其支撑环境具有基础指导意义.     

Flash ActionScript 2．0编程技术的研究

Flash是当前较流行的二维动画制作软件，除具备强大的动画制作功能外，随着Flash MX2004及ActionScript 2．0的发布，实现了较完整的面向对象编程模型，具备了开发大型应用程序的能力。文章介绍了Flash MX 2004的特点，分析了ActionScript 2．0的编程特性。