Showing papers on "Object model published in 1995"

The 4+1 View Model of architecture

Abstract: The 4+1 View Model organizes a description of a software architecture using five concurrent views, each of which addresses a specific set of concerns. Architects capture their design decisions in four views and use the fifth view to illustrate and validate them. The logical view describes the design's object model when an object-oriented design method is used. To design an application that is very data driven, you can use an alternative approach to develop some other form of logical view, such as an entity-relationship diagram. The process view describes the design's concurrency and synchronization aspects. The physical view describes the mapping of the software onto the hardware and reflects its distributed aspect. The development view describes the software's static organization in its development environment. >

Alignment by maximization of mutual information

Abstract: A new information-theoretic approach is presented for finding the pose of an object in an image. The technique does not require information about the surface properties of the object, besides its shape, and is robust with respect to variations of illumination. In our derivation, few assumptions are made about the nature of the imaging process. As a result, the algorithms are quite general and can foreseeably be used in a wide variety of imaging situations. Experiments are presented that demonstrate the approach in registering magnetic resonance images, aligning a complex 3D object model to real scenes including clutter and occlusion, tracking a human head in a video sequence and aligning a view-based 2D object model to real images. The method is based on a formulation of the mutual information between the model and the image. As applied in this paper, the technique is intensity-based, rather than feature-based. It works well in domains where edge or gradient-magnitude based methods have difficulty, yet it is more robust then traditional correlation. Additionally, it has an efficient implementation that is based on stochastic approximation. >

Method and apparatus for automatic generation of object oriented code for mapping relational data to objects

Abstract: A method and apparatus are provided for using an object model of an object-oriented application to automatically map information between an object-oriented application and a structured database, such as a relational database. This is done by taking into account all of the semantics (implications) of an object model, such as inheritance and relationships among object classes, and using these semantics to generate a minimal set of routines for each object class that manipulate the object and other objects to which it is related or from which it inherits. The generated routines, when executed, provide transparent access to relational data or other field-delimited data. Object classes and routines generated using the method encapsulate all the details of database access, such that developers (computer programmers) can write object-oriented applications using those object classes without any explicit reference to or knowledge of the underlying database or its structure. By working with the objects, the user of such applications transparently manipulates the database without needing to know anything of its structure. Applications can be written using the object classes to transparently integrate information from multiple databases.

ConceptBase—a deductive object base for meta data management

Abstract: Deductive object bases attempt to combine the advantages of deductive relational databases with those of object-oriented databases. We review modeling and implementation issues encountered during the development of ConceptBase, a prototype deductive object manager supporting the Telos object model. Significant features include: 1) The symmetric treatment of object-oriented, logic-oriented and graph-oriented perspectives, 2) an infinite metaclass hierarchy as a prerequisite for extensibility and schema evolution, 3) a simple yet powerful formal semantics used as the basis for implementation, 4) a client-server architecture supporting collaborative work in a wide-area setting. Several application experiences demonstrate the value of the approach especially in the field of meta data management.

System and method for providing interoperability among heterogeneous object systems

Abstract: A system and method in accordance with a preferred embodiment enable objects from two or more heterogeneous object systems in a digital computer to interoperate and be combined in the creation of a larger object-oriented software project, as well as uses of such system and method. Objects from a foreign object system are unmodified, yet appear to be native to the object system in which they are used or accessed. A native proxy object (indistinguishable from other native objects) is constructed for the real foreign object. The proxy object contains an identifier to the real object, as well as a pointer to a software description of how to access and manipulate the object - e.g. how to call its methods, set its properties, and handle exceptions. When the proxy object is manipulated, it follows the instructions in the software description which, in turn, results in the corresponding manipulation of the foreign object.

Principal component analysis with missing data and its application to polyhedral object modeling

Abstract: Observation-based object modeling often requires integration of shape descriptions from different views. To overcome the problems of errors and their accumulation, we have developed a weighted least-squares (WLS) approach which simultaneously recovers object shape and transformation among different views without recovering interframe motion. We show that object modeling from a range image sequence is a problem of principal component analysis with missing data (PCAMD), which can be generalized as a WLS minimization problem. An efficient algorithm is devised. After we have segmented planar surface regions in each view and tracked them over the image sequence, we construct a normal measurement matrix of surface normals, and a distance measurement matrix of normal distances to the origin for all visible regions over the whole sequence of views, respectively. These two matrices, which have many missing elements due to noise, occlusion, and mismatching, enable us to formulate multiple view merging as a combination of two WLS problems. A two-step algorithm is presented. After surface equations are extracted, spatial connectivity among the surfaces is established to enable the polyhedral object model to be constructed. Experiments using synthetic data and real range images show that our approach is robust against noise and mismatching and generates accurate polyhedral object models. >

Querying Semistructured Heterogeneous Information

Abstract: Semistructured data has no absolute schema fixed in advance and its structure may be irregular or incomplete. Such data commonly arises in sources that do not impose a rigid structure (such as the World-Wide Web) and when data is combined from several heterogeneous sources. Data models and query languages designed for well structured data are inappropriate in such environments. Starting with a “lightweight” object model adopted for the TSIMMIS project at Stanford, in this paper we describe a query language and object repository designed specifically for semistructured data. Our language provides meaningful query results in cases where conventional models and languages do not: when some data is absent, when data does not have regular structure, when similar concepts are represented using different types, when heterogeneous sets are present, and when object structure is not fully known. This paper motivates the key concepts behind our approach, describes the language through a series of examples (a complete semantics is available in an accompanying technical report [QRS+94]), and describes the basic architecture and query processing strategy of the “lightweight” object repository we have developed.

Realm-based spatial data types: the ROSE algebra

Abstract: Spatial data types or algebras for database systems should (1) be fully general, that is, closed under set operations, (2) have formally defined semantics, (3) be defined in terms of finite representations available in computers, (4) offer facilities to enforce geometric consistency of related spatial objects, and (5) be independent of a particular DBMS data model, but cooperate with any. We present an algebra that uses realms as geometric domains underlying spatial data types. A realm, as a general database concept, is a finite, dynamic, user-defined structure underlying one or more system data types. Problems of numerical robustness and topological correctness are solved within and below the realm layer so that spatial algebras defined above a realm have very nice algebraic properties. Realms also interact with a DMBS to enforce geometric consistency on object creation or update. The ROSE algebra is defined on top of realms and offers general types to represent point, line, and region features, together with a comprehensive set of operations. It is described within a polymorphic type system and interacts with a DMBS data model and query language through an abstract object model interface. An example integration of ROSE into the object-oriented data model O2 and its query language is presented.

A formal semantics for object model diagrams

Abstract: Informal software development techniques, such as the object modeling technique (OMT), provide the user with easy to understand graphical notations for expressing a wide variety of concepts central to the presentation of software requirements. OMT combines three complementary diagramming notations for documenting requirements: object models, dynamic models, and functional models. OMT is a useful organizational tool in the requirements analysis and system design processes. Currently, the lack of formality in OMT prevents the evaluation of completeness, consistency, and content in requirements and design specifications. A formal method is a mathematical approach to software development that begins with the construction of a formal specification describing the system under development. However, constructing a formal specification directly from a prose description of requirements can be challenging. The paper presents a formal semantics for the OMT object model notations, where an object model provides the basis for the architecture of an object oriented system. A method for deriving modular algebraic specifications directly from object model diagrams is described. The formalization of object models contributes to a mathematical basis for deriving system designs. >

Migrating to object technology

Abstract: 1. The Need For ObjectTechnology The Adaptable Business The Productive Developer The Satisfied User OT as the Oly Trinity 2. Inter-Operation, Reuse And Migration Inter-Operation of Object-Oriented Systems with Conventional IT Data Management Strategies D> Practical Problems with Migration to Object Technology Reusing Existing Software Components and Packages Combining Relational and Object-Oriented Databases Wrappers for Expert Systems and Blackboard Systems Using Object-Oriented Analysis as a Springboard 3. Building Graphical User Interfaces The Need for GUIs GUI Tools and Languages Designing the HCI GUI Standards Multi-media Systems, Virtual Reality and Optical Storage Case Studies 4. Distributed Systems, Databases And Object Management Modeling Distributed Systems The Client/Server Model Distributed Databases and Full-Content Retrieval Collaborative Work, Work Flow Automation and Graphics Network and Architectural Issues Object Request Brokers and Distributed Objects Case Studies Difficulties in Implementing Distributed and Client/Server Systems Case Studies 5. Building Expert Systems Fundamentals of Expert Systems Knowledge Representation Inference in Knowledge Based Systems Fuzzy Rules and Fuzzy Objects Frames and Objects Script Theory Blackboard Architectures Fuzzy and Neural Systems Implementation in an Expert Systems Environment Part II Migration Using SOMA 6. Object Modeling Basic Philosophy What is an Object-Oriented Analysis Method? The OMG and Abstract Object Models The Models of Software Engineering Objects Layers Finding Objects Structures Responsibilities Rules and Rulesets State Model Notation D>Fuzzy Extensions Deliverables 7. Requirements Capture And Analysis Object-Oriented Analysis Methods The Requirements Capture Process Context Modeling and the Environment Model Task Analysis: Task-Scripts, Subscripts, Component Scripts and Side-Scripts Identifying Objects Building the Object Model Refining the Task-Scripts to Identify Responsibilities Creating Class Cards and Walking Through the System Objects with Complex States Setting Priorities and Running Object-Oriented RAD Workshops 8. Strategic Modeling And Business Process Re-Engineering Object-Oriented Enterprise Modeling The Zachman Framework Modeling and Re-Engineering the Business Business Policy and Fuzzy Models Deliverables 9. Life-Cycle What Must an Object-Oriented Model Do? Life-Cycle Models RADs, Time Boxes and Evolutionary Development The SOMA Process Model General Project Management Tasks Roles, Skills and Responsibilities Hacking as a Structured Activity 10. Metrices, Estimation And Testing Metrics, Measures and Models Estimation Techniques Metrics for Object-Oriented systems Analysis The SOMA Metrics Testing Techniques Quality Measurement 11. Coordination And Reuse Component Management and Reuse Class Libraries and Library Control The Process Environment and Rools Designing for Reuse Repositories and CASE Tools Cross-Project Coordination 12. Moving To Physical Design And Implementation Converting Rules to Assertions Specification as Implementation and the Benefits of Prototyping The Shift of the Breakpoint (Continuum of Not?) Modeling Systems Dynamics Use of Effect Correspondence Diagrams and Other Matrix Techniques Physical Design Implementation in an Object-Oriented Language Implementation in a Conventional Language Integration of Class Libraries Code Generation Formal Methods and Logic Deliverables 13. Case Studies SOMA in SOMA Migrating a Large Software Product Building a Trading System Building a Graphical user Interface A Process Model for Migration Standards

Visual programming tool for developing software applications

Abstract: A visual programming method implemented on a computer having a display screen and an input device which a user employs to draw visual representations on the display screen, including the steps of defining and supporting by computer implemented steps a set of object classes including a linking object class; in response to input from the user, selecting a first object class; in response to the user using the input device to draw a first visual representation on the display screen, generating a source object, which is an instance of the first object class and having a first set of events associated therewith; in response to input from the user, selecting a second object class; and in response to the user using the input device to draw a second visual representation on the display screen, generating a destination object, which is an instance of the second object class; in response to input from the user, selecting the linking object class; and in response to the user using the input device to draw a third visual representation that connects the first and second visual representations, generating a linking object, which is an instance of the linking object class and has associated therewith a set of user selectable predefined behaviors, each of which is in the form of a set of commands that defines actions that occur to the destination object in response to an occurrence of one of the events of the first set of events.

CORBA: A Guide to Common Object Request Broker Architecture

Abstract: The object management group the OMG object model the common object request broker architecture language bindings to IDL object services - commmon object services 1 object services - common object services 2 the object database management group - part 1 the object database management group standard IBM's system object model (SOM) Sun's Project DOE (distributed objects everywhere) DEC's object broker and the COM/OLE2 link HP's distributed smalltalk.

Der Ansatz des Semantischen Objektmodells (SOM) zur Modellierung von Geschäftsprozessen.

Abstract: The paper presents the methodical principles of business process modeling using the Semantic Object Model (SOM). The entire modeling approach of the Semantic Object Model (SOM approach) comprises layers for the enterprise plan, for business processes, and for application systems. Business processes are interpreted as procedures to carry out the enterprise plan. Application systems are interpreted as one of the resources for executing business processes. Based on an integrated meta model, the SOM approach supports a semi-formal modeling technique using object-oriented and transaction-oriented paradigms.

Network controller for monitoring the status of a network

Abstract: A network controller for monitoring the status of a network includes a hierarchical object-based data structure representative of the network to be controlled. The data structure includes a set of hierarchically linked objects representative of elements of the network and each object includes object parameters including an object status parameter (e.g., a fault parameter) and, with the exception of the root object of the object hierarchy, a pointer to a parent object. A graphical user interface is configured to display one or more views of an object and is responsive to the selection of a displayed object by user. The controller can provide a hierarchical view of the objects and/or a physical location view of at least selected objects from the hierarchy. The display of objects associated with faults is highlighted to facilitate identification and the controller allows the operator to navigate through the object structure.

System for interconnecting software components in an object oriented programming environment using a separate editor object for each run-time object instantiated for each selected component

Abstract: A method and system for interconnecting software components. In a preferred embodiment, the present invention instantiates an event object. The event object includes message information describing the message and a dispatching member function for invoking a member function of a target object passing the message information. A message is passed by invoking the dispatching member function of the event object passing an identifier to a target object and an identifier of a member function of the target object. The dispatching member function invokes the identified member function of the identified target object passing the event information as an actual parameter. The event object is preferably of a derived class that inherits a base class. The base class provides common event behavior, while the derived class provides behavior specific to a type of message.

Meta-level Programming with CodA

Abstract: Meta-levels are complex pieces of software with diverse demands in both the computation and interaction domains. Common techniques using just code to express behaviour fail to clearly assign responsibility for a particular behaviour's definition or to provide support for the reuse or integration of existing behaviour descriptions. The techniques of fine-grained decomposition of meta-level behaviour into objects and their subsequent composition into object models provides a framework for creating, reusing and integrating complex object behaviours. Using such a framework, we show that users can develop and integrate quite different object models while retaining a high degree of abstraction and fostering meta-level component reuse.

Efficient method router that supports multiple simultaneous object versions

Abstract: OOP environments comprise composite data structures and internal mechanisms for manipulating those structures. The structures are used to allow a user to realize the power of OOP. Hence, the layout of these structures, the way in which the structures inter-relate, and the manner in which they are built and used are all critical to the utility of a particular OOP environment. It is no surprise, then, that manufacturers and suppliers of OOP environments are constantly striving to design composite data structures and internal mechanisms which maximize user productivity. The internal mechanisms and structures that make up the present invention are collectively referred to as the New Object Model (NOM). The composite data structures and organization of the NOM OOP environment provide significant benefits that are not provided by the environments of the prior art. These benefits include: a more efficient method resolution scheme and the ability to add method programs and object instance data to a class definition without the need to recompile the majority of the code base.

Creating solid models from single 2D sketches

Abstract: We describe a method of constructing a B-rep solid model from a single hidden-line removed sketch view of a 3D object. The main steps of our approach are as follows. The sketch is first tidied in 2D (to remove digitisation errors). Line labelling is used to deduce the initial topology of the object and to locate hidden faces. Constraints are then produced from the line labelling and features in the drawing (such as probable symmetry) involving the unknown face coefficients and point depths. A least squares solution is found to the linear system and any grossly incompatible equations are rejected. Vertices are recalculated as the intersections of the faces to ensure we have a reconstructible solid. Any incomplete faces are then completed as far as possible from neighbouring faces, producing a solid model from the initial sketch, if successful. The current software works for polyhedral objects with trihedral vertices. CR Descriptors: I.3.5 [Computer Graphics]: Computational Geometry and Object Modelling Geometric algorithms, languages and systems; I.2.10 [Artificial Intelligence]: Vision and Scene Understanding Perceptual reasoning; I.3.6 [Computer Graphics]: Methodology and Techniques Interaction techniques; J.6 [Computer Applications]: CAE CAD.

A Delegation-based Object Calculus with Subtying

Abstract: This paper presents an untyped object calculus that reflects the capabilities of so-called delegation-based object-oriented languages. A type inference system allows static detection of errors, such as message not understood, while at the same time allowing the type of an inherited method to be specialized to the type of the inheriting object. The main advance over previous work is the provision for subtyping in the presence of delegation primatives. This is achieved by distinguishing a prototype, whose methods may be extended or replaced, from an object, which only responds to messages for which it already has methods. An advantage of this approach is that we have full subtyping without restricting the “runtime” use of inheritance. Type soundness is proved using operational semantics and an analysis of typing derivations.

Method and apparatus for internal versioning of objects using a mapfile

Abstract: A method and apparatus for providing versioning information for a plurality of software objects. When an object is compiled and linked, at build time, the link-editor creates a version definition section and a version symbol section in the object that specify the global symbols defined in various versions of the object. The object can be a shared object, a relocatable object, or a dynamic executable object. When an application software program is linked with the versioned object, at build time, the linker-editor creates a version dependency section in the resulting dynamic executable object that specifies which version of the object is required for execution of the software application program. At runtime, the runtime-linker determines whether all required versions of the object are present before the program is executed. The invention allows the definition of "weak" versions that do not contain new global symbols. The invention also allows the explicit specification of the version of an object to which the software application program should be linked.

Method for supporting object modeling in a repository

Abstract: In a computer system having a user interface, a memory, a repository and a database, a repository program operating in the computer system for accessing the database, the repository program executing a method for supporting modeling, the method comprising the steps of examining a collection of types forming a model; sorting object types into data and persistent type objects; creating all data type objects and adding to a collection of all objects owned by the model; creating all persistent type objects and adding to a collection of all objects owned by the model; initializing all persistent type objects in the collection of objects.

Requirements validation via automated natural language parsing

Abstract: Object oriented analysis (OOA) has become a popular method for analyzing system requirements. Unfortunately however, none of the current versions of OOA have included a validation technique tailored to the object oriented approach. Most, instead, merely recommend document reviews without specifying what kinds of problems to look for. The paper explores the question by applying a natural language parser to a requirements document, extracting candidate objects, methods and associations, composing them into an object model diagram, and then comparing the results to those determined by manual OOA. To do this, we have adapted an automated natural language parser and used it to examine several high level specifications. The results indicate that with a modest amount of effort, our technique can give valuable feedback to the analyst. >

An event based object model for distributed programming

Abstract: This paper describes the rationale and design of a new distributed systems programming model based on events, constraints, and objects. The paper describes the inter-object communication or invocation mechanism, and the way in which concurrency, synchronisation, and timing properties are expressed and controlled. The invocation mechanism is unusual in that it is event-based. It encourages loose coupling among the objects and a high degree of encapsulation for each object. Concurrency, synchronisation, and timing properties are expressed in a uniform way using constraints which may be associated with objects and events.

Map-aided structural analysis of aerial images

Abstract: A syntax-oriented method for a map-aided analysis of structures in aerial images is proposed. First the map must be analysed in order to obtain a suitable representation of its knowledge content. A special kind of graph, a so-called image-description graph, is the result of this map analysis. The knowledge of the map, represented on different description levels, is used to control the search process during the image analysis. Based on this knowledge, expectations for attribute values of image objects are defined. Generated objects are assessed relative to the expectations of the map and the object model. A set-oriented selection method is applied to deduce the processing priority using these two assessments. Expected objects are preferably processed for building up more complex objects. Thus the map-aided analysis can be used to reduce the processing time for a verification task.

Tigukat: a uniform behavioral objectbase management system

Abstract: We describe the TIGUKAT objectbase management system, which is under development at the Laboratory for Database Systems Research at the University of Alberta. TIGUKAT has a novel object model, whose identifying characteristics include a purely behavioral semantics and a uniform approach to objects. Everything in the system, including types, classes, collections, behaviors, and functions, as well as meta-information, is a first-class object with well-defined behavior. In this way, the model abstracts everything, including traditional structural notions such as instance variables, method implementation, and schema definition, into a uniform semantics of behaviors on objects. Our emphasis in this article is on the object model, its implementation, the persistence model, and the query language. We also (briefly) present other database management functions that are under development such as the query optimizer, the version control system, and the transaction manager.

Dynamic object management method in object oriented language

Abstract: In an object oriented language, a class object is modified by using meta operators to create a floating class object by copying from a class object, modifying the floating class object into a new class object and link the new class object with its original class object by a linking describing both the history of the modification and the relationship between the new class object and the original class object, and an instance object is modified by using meta operators to create a floating instance object by modifying the existing instance object and linking the modified instance object with its original class object by a link describing the modification and the relationship between modified instance object and the original class object.

An Imperative Object Calculus

Abstract: We develop an imperative calculus of objects. Its main type constructor is the one for object types, which incorporate variance annotations and Self types. A subtyping relation between object types supports object subsumption. The type system for objects relies on unusual but beneficial assumptions about the possible subtypes of an object type. With the addition of polymorphism, the calculus can express classes and inheritance.

A mechanism of automatic 3D object modeling

Abstract: The symbolic representation of 3D objects is the fundamental knowledge for computer systems to understand the environment. This knowledge is usually assumed to exist in a computer but can also be acquired by accumulating spatial features extracted from sensory inputs at different viewing directions. This paper first investigates surface visibility and, then, after introducing mass vector chains (MVC), discusses the relationship between MVC and the spatial closure of object models. An automatic modeling mechanism is established with the observation that the boundary of an object is closed only if the MVC of its model is closed or, alternatively, the tail-to-head vector of an unclosed MVC estimates the visible direction of the missing surfaces. Experimental results and an algorithm are also given at the end. >