Multiple object interfaces in object-oriented control systems

In this paper we have shown how the description of application objects and interface objects can be formalized and applied to the speci cation of a highly interactive system. We have presented the Abstract Data View (ADV) model which is a design concept for the speci cation of interfaces. An ADV can be used to represent an interface between a user, a network or a device such as a timer and an Abstract Data Object (ADO), or as an interface between two or more ADOs, where an ADO is a speci cation for an object's public interface. Thus, ADVs can be viewed as media transformers or transformers between ADOs, and can add a \reuse dimension" to design, since they can determine the way in which one object \views" another, and could support syntactic non-interference and semantic context independence among di erent object speci cations. Our experience has shown that the practical use of ADV/ADOs in object-oriented design is related to both the formulation of reusable design patterns and to the reuse of existing ones. We view designs as being composed of ADVs and ADOs, and in order to specify a design we require a speci cation framework that provides adequate descriptions of the properties of ADVs and ADOs, and their components. This paper presents such a framework based on descriptive schemas for both ADVs and ADOs. These schemas describe the structural, static, and dynamic features of each system object, and include the speci cation of the concurrent operation of system components. Additionally, such schemas can be seen as an underlying structure to support the development of a speci cation language that describes the interconnection between interface and application components.

1999

Object-oriented software evolves over time, and it would be ideal if we could capture the persistent parts of the software early on and then derive the transient versions of the software from the persistent parts. Capturing the persistent parts of the software allows us to better maintain the integrity of the program during its evolution. This is the goal of software architecture. In this paper, we emphasize an approach called O3ML (Operational Object-Oriented Modeling Language) to model complex software systems using a sound software architecture which is centered on the creation of a system prototype with integrated design requirements and a simulation framework. This methodology supports the prototyping of complex computer-based systems by providing: (a) a multi-domain approach to capture the architectural complexity of real-world systems; and (b) a mechanism for the simulation of the conceptual, functional and implementation features of the design and the user requirements

ACM SIGSOFT Software Engineering Notes, 1995

In this paper we present a formal approach of a new object-oriented design concept to support reuse-in-thelarge called Abstract Data Views (ADVS). The ADV approach was created to specify clearly and formally the separation of interfaces from the application components of a software system. Such an approach should lead to a high degree of reuse of designs for both interface and application components. Our specification framework is based on descriptive schemas for both ADVS and ADOS, that are the basic building blocks for the system specification, design, and implementation using the ADV approach. These schemas describe the structural, static, and dynamic feat ures of each system object, and include the specification of the concurrent operation of system components. Additionally, such schemas can be seen as an underlying structure to support the development of a specification language that describes the interconnection between interface and application components.

Control Engineering Practice, 1999

The paper focuses on how the object-oriented paradigm can be exploited as a valid modelling technique in many engineering fields and, in particular, in advanced automation engineering. The most typical features of object-oriented modelling techniques include the encapsulation of data, functions to access such data into objects, and the hierarchical composition of objects. On the other hand, the large majority of complex systems, like industrial plants and distributed control systems, can be decomposed into a hierarchical structure that facilitates system comprehension, design and control. For the above reasons, the object-oriented modelling technique is suited to real world modelling, in particular to representing the hybrid dynamics (continuous-time, discrete-time and discrete-event) of industrial plants.

Computing science notes, 1994

In this paper we discuss the fundamental concepts present in the object-oriented methodology. First we concentrate on the notion of an object, the key concept in this approach. A (software) object is the abstract representation of a physical or conceptual object. It consists of a name, a specified set of data-elements and methods. Data-elements can have values attached to them. Data-hiding is the feature that certain data and methods can be kept invisible (= hidden) for the outside of an object, thus facilitating its description. Only knowledge on the nature of the visible data-elements and methods is required to make proper use of the object. This is called data-abstraction. A related concept is encapsulation, a technique for achieving both data-hiding and data-abstraction. A class is a template for a number of similar objects. Classes do not prescribe values for the data-elements nor fixed implementations for their methods. A class can be seen as a set of objects that satisfy the same specification for data-elements and method-behavior. An alternative grouping of objects may take place by means of object types, as we will describe. A type is a set of objects that satisfy the same ezternai specification, i.e., specification of the visible data-elements and methods. Thus, a classification via types differs from an ordering into classes, as we shall explain. The notion of type brings along a notion of subtyping. We also discuss different forms of inheritance between classes. By means of inheritance a class can use data-and method-descriptions from another class. We describe, among other things, single inheritance, multiple inheritance and overriding. We also discuss mUltiple preferred inheritance and runtime inheritance. Finally, we show how actual programming can take place in an object oriented approach. For that we need a description of inter-object communication by means of messages. Relevant aspects are: synchronous and asynchronous message passing, scheduling and delegation. The paper concludes with an overview and a number of summarizing remarks. "'This paper originates from Marc van der Kammen's master's thesis "The logic of objects; object oriented programming in a logical perspective". It is the revised version of his chapter 0, which contains an overview of the most important basic notions concerning object-oriented programming.

2007

Graphical variant modeling refers to a novel approach to object-oriented modeling whereby a class overrides behavior inherited from a parent class by specifying variations in the graphical description of that behavior. This approach differs from conventional approaches wherein object behavior is overridden by replacing the entire description. This paper outlines the potential benefits of graphical variant modeling. It provides a detailed description of an experimental modeler, based on a declarative block diagram language, developed as a test bench for prototyping graphical variant modeling tools and verifying the benefits of the approach in industrial modeling applications. The paper ends with some preliminary conclusions about the potential benefits of graphical variant modeling based on the development and initial usage of the experimental modeler.

ABSTRACT Software industry increasingly faces today the challenge of creating complex custom-made Industrial Process Measurement and Control System (IPMCS) applications within time and budget, while high competition forces prices down. A lot of proprietary solutions address the engineering process, and evolving standards exploit the function block construct as the main building block for the development of IPMCSs.

IFIP Advances in Information and Communication Technology, 1996

Engineering design, as one of the most challenging application areas for Computer-Aided Engineering, requires the representation of complex data elements as well as complex relationships among them. Users in these environments have found traditional technology inadequate in terms of flexibility, modelling power and efficiency. Thus, it becomes necessary to develop environments capable of supporting the various paradigms used in large projects. Such environments require a good data and knowledge representation, efficient programing features, adequate mechanisms for storage and concurrency control and good communications with other software systems. In this paper, we discuss the main characteristics of the engineering design products and the limitations of the current design product models. And then, we present the main features of an improved object-oriented representation model PDM and its implementation MOSS. An example is given for demonstrating the application of the objectoriented representation model PDM and the object-oriented programming environment MOSS in the field of mechanical CAD.

ACM SIGPLAN Notices, 1987

Object-oriented programming is a promising approach to the industrialization of the software development process. However, it has not yet been incorporated in a development method for large systems. The approaches taken are merely extensions of well-known techniques when 'programming in the small' and do not stand on the firm experience of existing developments methods for large systems. One such technique called block design has been used within the telecommunication industry and relies on a similar paradigm as object-oriented programming. The two techniques together with a third technique, conceptual modeling used for requirement modeling of information systems, have been unified into a method for the development of large systems.

Lecture Notes in Computer Science, 1999

The UML as standardized language for visual object-oriented modeling allows to capture the requirements as well as the structure and behavior of complex software systems. With the increasing demands of todays systems, behavior aspects like concurrency, distribution and reactivity become more important. But the language concepts of the UML for describing behavioral aspects are weak compared to its concepts for describing structures. Besides a lack of visual expressiveness, a deeper integration with the structure specification is missing. In order to close this gap, an expressive language for modeling object-oriented behavior is proposed with the OCoN approach. It describes contracts, object scheduling as well as control and data flow of services in a Petri-net-like form. A seamless visual embedding of contract specifications into service and object scheduling specifications is provided by different net types.

Proceedings of the 15th IFAC World Congress, 2002, 2002

This paper presents a novel modelling approach for hybrid industrial plants. It is based on the introduction of object-oriented concepts to the Differential Predicate Transition nets. To handle the system complexity a top-down methodology is considered, where class models are successively refined and decomposed. The UML language is also used to represent different views of the modelled system. A cane sugar factory is used as an example to illustrate the proposed approach.

The Journal of Object Technology, 2002

The separation of concerns, as a conceptual tool, enables us to manage the complexity of the software systems that we develop. A number of approaches have been proposed that aim at modularizing software around the natural boundaries of the various concerns, including subject-oriented programming (SOP) [Harrison & Ossher, 1993] aspect-oriented programming (AOP) [Kiczales et al., 1997], and our own view-oriented programming (VOP) [Mili et al., 1999]. Both SOP and AOP support compile-time composition. A major advantage of VOP is run-time behavioral composition, which comes at the expense of a cumbersome dispatching mechanism. The same applications that warrant the kind of separation supported by these techniques tend also to be distributed whereby different client sites see different compositions of aspects, simultaneously. The level of indirection provided by distribution middleware simplifies the programming model, and reduces the overhead of VOP. CORBAVIEWS-DISTRIBUTING OBJECTS THAT SUPPORT SEVERAL FUNCTIONAL ASPECTS 208 J OURNAL OF OBJECT TECHNOLOGY V OL. 1, NO. 3 The transition from analysis to design consists of deriving an implementation of the functionalities specified at analysis time in a way that satisfies design-level constraints and addresses design-level concerns. Such concerns include error handling, synchronization, logging, access to lower-level services, and the like. Addressing these concerns usually means adding code that crosscuts normal modularization boundaries, i.e. typically objects and methods. These are but three of the most common situations requiring us to modularize programs along dimensions other than the traditional function, class, or method, inherent in both procedural and object-oriented programming. There have been a number of approaches to providing language-level support for separation of concerns in the OO research community. Each one of these approaches was intended to solve one particular set of problems related to the three mentioned above. The concept of views in OOP was first introduced by Shilling and Sweeny [Shilling & Sweeny, 1989] as a filter of a global interface of the class, but the views are not separable or separately reusable. Aksit et al. presented composition filters as a way of intercepting incoming and outgoing messages [Aksit et al., 1992]. However, the filters add no state, and can only modify existing behavior without adding new ones. Harrison and Ossher [Harrison & Ossher, 1993] proposed subject-oriented programming as a way to build integrated "multiple view" applications by composing application fragments, called subjects, which represent compilable and possibly executable functional slices [Harrison & Ossher, 1993]. However, the composition of subjects takes place at compilation time, and offers few degrees of freedom. Aspect oriented programming captures concerns that crosscut several entities in new constructs called aspects that are woven into the structure of functional code [Kiczales et al., 1997]. However, aspect "weaving" also takes place at compilation time, and aspects do not necessarily correspond to domain-level behavior. The problem of dynamic adaptation has been addressed by a number of researchers. Earlier approaches were based on variations of the adapter/decorator design pattern. The problem with such approaches is that the various adapters (and the classes they adapt) have to be known beforehand [Buchi & Weck, 2000]. Two approaches attempt to address this problem in a type-safe fashion: Kniesel, with Darwin/Lava [Kniesel, 1999], and Büchi & Weck's generic wrappers concept [Buchi & Weck, 2000]. Presumably, both approaches enable an object to offer different interfaces to different client programs. With generic wrappers, the various interfaces have to be hierarchically composed. Further, with both approaches, the adapter and "adapted" have different object identities, and neither approach handles distribution explicitly. It turns out that the same applications that warrant the use of separation of concern techniques also tend to be the kind of applications that are distributed and that offer different sets of functionalities to different user communities. In summary, we have a situation where: 1. Objects acquire and lose behavior dynamically (the dynamic behavior change problem),

2010

Current component-based approaches for distributed control systems enable the reuse of mechatronic components, for example specific grippers or conveyor belts, but do not allow full application reuse as the actual hardware configuration is an implicit part of the software solution. In contrast to the current object-oriented or component-based engineering models for automation engineering, this paper will introduce a new Model-Driven Architecture based application and hardware modeling approach. Through separation of the logical application domain and the specific hardware domain the logical application is completely independent of the concrete physical plant configuration. Therefore development time for automation applications can be vastly reduced and software quality can be improved.