This research is concerned with inheritance as used in object-oriented database. More specifically, partial bi-directional inheritance among classes is examined. In partial inheritance, a class can inherit a proper subset of instance variables from another class. Two subclasses of the same superclass do not need to inherit the same proper subset of instance variables from their superclass. Bi-directional partial inheritance allows a class to inherit instance variables from its subclass. The prototype of an object-oriented database that supports both full and partial bi-directional inheritance among classes was developed on top of an existing relational database management system. The prototype was tested with two database applications. One database application needs full and partial inheritance. The second database application required bi-directional inheritance. The result of this testing suggests both advantages and disadvantages of partial bi-directional inheritance. Future areas of research are also suggested.

FOOPS is a concurrent object oriented specification language with an executable subset. In this thesis we propose an extension of FOOPS with features for specifying systems of distributed and autonomous objects. This extension supports most features of concurrent object oriented programming, including classes of objects with associated methods and attributes, object identity, dynamic object creation and deletion, overloading, polymorphism, inheritance with overriding, dynamic binding, concurrency, nondeterminism, atomic execution, evaluation of method expressions as background processes, and object protection. The main contribution of this thesis is to develop a framework for supporting formal development of software in the extension of FOOPS mentioned above. In particular, we introduce a structural operational semantics for FOOPS, a notion of refinement for concurrent object oriented programs, congruence properties of refinement of FOOPS programs, and tools for mechanising refinement proofs. The operational semantics is the core of the formal definition of FOOPS. It is used to define notions of refinement for FOOPS states, programs, and specifications. Those notions and associated proof techniques for proving refinement are used to illustrate stepwise formal development of programs in FOOPS. The congruence properties of refinement (with respect to some of FOOPS operators) justify compositional development of software in FOOPS. The tools help to validate the framework introduced in this thesis and motivate its use in practice.

A project report submitted to the Faculty of Erlglncerlng, University of Witwatersrand, Johannesburg, In partial fulfilment of the requirements for the degree of Master of Science In Engineering Johannesburg 1993 / This Project Repolt r ''"lorts on the study of an approach to building integrated real-time software systems based on re-usable object-oriented components. The basis of the approach is the development of a a-layered structure of components, where each layer is built on the underlying layer of components, The lower layer of components consists of generic re-usable building blocks that may be re-used for building and integrating other real-time applications. The middle layer consists of components that are generic to the application domain, and the top layer consists of components that are specific to each application of that application domain. The Report includes researching and developing methods of communicating between these building blocks using an OSI/CMIP-conformant 'software highway" and in this regard particular attention is given to the formal and de facto industry standards. With this approach, it is argued that the application engineer can effectively build new applications using the re-usable components. This is demonstrated by reporting on the implementation of a large real-world Telecommunications Network Management application. The Project Report contains a critical analysis of the technical, organisational and project management issues of this Object-oriented component approach as compared to the traditional development approach. The Report concludes that despite certain technical and organisational concerns, the object-oriented approach does indeed yield several worthwhile benefits for developing real-time software systems. These benefits include genuine re-usability, and l"1proved productivity, testability and maintainability.

by Chi-keung Luk. / Thesis (M.Phil.)--Chinese University of Hong Kong, 1993. / Includes bibliographical references (leaves 169-174). / Preface --- p.xi / Chapter 1 --- Introduction --- p.1 / Chapter 1.1 --- Programming Languages --- p.2 / Chapter 1.2 --- Programming Paradigms --- p.2 / Chapter 1.2.1 --- What is a programming paradigm --- p.2 / Chapter 1.2.2 --- Which came first? Languages or paradigms? --- p.2 / Chapter 1.2.3 --- Overview of some paradigms --- p.4 / Chapter 1.2.4 --- A spectrum of paradigms --- p.6 / Chapter 1.2.5 --- Mulitparadigm systems --- p.7 / Chapter 1.3 --- The Objectives of this research --- p.8 / Chapter 2 --- "Studies of the object-oriented, the logic and the functional paradigms" --- p.10 / Chapter 2.1 --- The Object-Oriented Paradigm --- p.10 / Chapter 2.1.1 --- Basic components --- p.10 / Chapter 2.1.2 --- Motivations --- p.11 / Chapter 2.1.3 --- Some related issues --- p.12 / Chapter 2.1.4 --- Computational models for object-oriented programming --- p.16 / Chapter 2.2 --- The Functional Paradigm --- p.18 / Chapter 2.2.1 --- Basic concepts --- p.18 / Chapter 2.2.2 --- Lambda calculus --- p.20 / Chapter 2.2.3 --- The characteristics of functional programs --- p.21 / Chapter 2.2.4 --- Practicality of functional programming --- p.25 / Chapter 2.3 --- The Logic Paradigm --- p.28 / Chapter 2.3.1 --- Relations --- p.28 / Chapter 2.3.2 --- Logic programs --- p.29 / Chapter 2.3.3 --- The opportunity for parallelism --- p.30 / Chapter 2.4 --- Summary --- p.31 / Chapter 3 --- A survey of some existing multiparadigm languages --- p.32 / Chapter 3.1 --- Logic + Object-Oriented --- p.33 / Chapter 3.1.1 --- LogiC++ --- p.33 / Chapter 3.1.2 --- Intermission --- p.34 / Chapter 3.1.3 --- Object-Oriented Programming in Prolog (OOPP) --- p.36 / Chapter 3.1.4 --- Communication Prolog Unit (CPU) --- p.37 / Chapter 3.1.5 --- DLP --- p.37 / Chapter 3.1.6 --- Representing Objects in a Logic Programming Language with Scoping Constructs (OLPSC) --- p.39 / Chapter 3.1.7 --- KSL/Logic --- p.40 / Chapter 3.1.8 --- Orient84/K --- p.41 / Chapter 3.1.9 --- Vulcan --- p.42 / Chapter 3.1.10 --- The Bridge approach --- p.43 / Chapter 3.1.11 --- Discussion --- p.44 / Chapter 3.2 --- Functional + Object-Oriented --- p.46 / Chapter 3.2.1 --- PROOF --- p.46 / Chapter 3.2.2 --- A Functional Language with Classes (FLC) --- p.47 / Chapter 3.2.3 --- Common Lisp Object System (CLOS) --- p.49 / Chapter 3.2.4 --- FOOPS --- p.50 / Chapter 3.2.5 --- Discussion --- p.51 / Chapter 3.3 --- Logic + Functional --- p.52 / Chapter 3.3.1 --- HOPE --- p.52 / Chapter 3.3.2 --- FUNLOG --- p.54 / Chapter 3.3.3 --- F* --- p.55 / Chapter 3.3.4 --- LEAF --- p.56 / Chapter 3.3.5 --- Applog --- p.57 / Chapter 3.3.6 --- Discussion --- p.58 / Chapter 3.4 --- Logic + Functional + Object-Oriented --- p.61 / Chapter 3.4.1 --- Paradise --- p.61 / Chapter 3.4.2 --- LIFE --- p.62 / Chapter 3.4.3 --- UNIFORM --- p.63 / Chapter 3.4.4 --- G --- p.64 / Chapter 3.4.5 --- FOOPlog --- p.66 / Chapter 3.4.6 --- Logic and Objects (L&O) --- p.66 / Chapter 3.4.7 --- Discussion --- p.67 / Chapter 4 --- The design of a multiparadigm language I --- p.70 / Chapter 4.1 --- An Object-Oriented Framework --- p.71 / Chapter 4.1.1 --- A hierarchy of classes --- p.71 / Chapter 4.1.2 --- Program structure --- p.71 / Chapter 4.1.3 --- Parametric classes --- p.72 / Chapter 4.1.4 --- Inheritance --- p.73 / Chapter 4.1.5 --- The meanings of classes and methods --- p.75 / Chapter 4.1.6 --- Objects and messages --- p.75 / Chapter 4.2 --- The logic Subclasses --- p.76 / Chapter 4.2.1 --- Syntax --- p.76 / Chapter 4.2.2 --- Distributed inference --- p.76 / Chapter 4.2.3 --- Adding functions and expressions to logic programs --- p.77 / Chapter 4.2.4 --- State modelling --- p.79 / Chapter 4.3 --- The functional Subclasses --- p.80 / Chapter 4.3.1 --- The syntax of functions --- p.80 / Chapter 4.3.2 --- Abstract data types --- p.81 / Chapter 4.3.3 --- Augmented list comprehensions --- p.82 / Chapter 4.4 --- The Semantic Foundation of I Programs --- p.84 / Chapter 4.4.1 --- T1* : Transform functions into Horn clauses --- p.84 / Chapter 4.4.2 --- T2*: Transform object-oriented features into pure logic --- p.85 / Chapter 4.5 --- Exploiting Parallelism in I Programs --- p.89 / Chapter 4.5.1 --- Inter-object parallelism --- p.89 / Chapter 4.5.2 --- Intra-object parallelism --- p.92 / Chapter 4.6 --- Discussion --- p.96 / Chapter 5 --- An implementation of a prototype of I --- p.99 / Chapter 5.1 --- System Overview --- p.99 / Chapter 5.2 --- I-to-Prolog Translation --- p.101 / Chapter 5.2.1 --- Pass 1 - lexical and syntax analysis --- p.101 / Chapter 5.2.2 --- Pass 2 - Class Table Construction and Semantic Checking --- p.101 / Chapter 5.2.3 --- Pass 3 - Determination of Multiple Inheritance Precedence --- p.105 / Chapter 5.2.4 --- Pass 4 - Translation of the directive part --- p.110 / Chapter 5.2.5 --- Pass 5 - Creation of Prolog source code for an I object --- p.110 / Chapter 5.2.6 --- Using expressions in logic methods --- p.112 / Chapter 5.3 --- I-to-LML Translation --- p.114 / Chapter 5.4 --- The Run-time Handler --- p.117 / Chapter 5.4.1 --- Object Management --- p.118 / Chapter 5.4.2 --- Process Management and Message Passing --- p.121 / Chapter 6 --- Some applications written in I --- p.125 / Chapter 6.1 --- Modeling of a State Space Search --- p.125 / Chapter 6.2 --- A Solution to the N-queen Problem --- p.129 / Chapter 6.3 --- Object-Oriented Modeling of a Database --- p.131 / Chapter 6.4 --- A Simple Expert System --- p.133 / Chapter 6.5 --- Summary --- p.138 / Chapter 7 --- Conclusion and future work --- p.139 / Chapter 7.1 --- Conclusion --- p.139 / Chapter 7.2 --- Future Work --- p.141 / Chapter A --- Language manual --- p.146 / Chapter A.1 --- Introduction --- p.146 / Chapter A.2 --- Syntax --- p.146 / Chapter A.2.1 --- The lexical specification --- p.146 / Chapter A.2.2 --- The syntax specification --- p.149 / Chapter A3 --- Classes --- p.152 / Chapter A.4 --- Object Creation and Method Invocation --- p.153 / Chapter A.5 --- The logic Subclasses --- p.155 / Chapter A.6 --- The functional Subclasses --- p.156 / Chapter A.7 --- Types --- p.158 / Chapter A.8 --- Mutable States --- p.158 / Chapter B --- User's guide --- p.160 / Chapter B.1 --- System Calls --- p.160 / Chapter B.2 --- Configuration Parameters --- p.162 / Chapter B.3 --- Errors --- p.163 / Chapter B.4 --- Implementation Limits --- p.164 / Chapter B.5 --- How to install the system --- p.164 / Chapter B.6 --- How to use the system --- p.164 / Chapter B.7 --- How to recompile the system --- p.166 / Chapter B.8 --- Directory arrangement --- p.167 / Chapter C --- List of publications --- p.168 / Bibliography --- p.169

by Kei-Fu Mak. / Thesis (M.Phil.)--Chinese University of Hong Kong, 1995. / Includes bibliographical references (leaves 103-108). / Chapter 1 --- Introduction --- p.1 / Chapter 1.1 --- Flynn's Classification --- p.1 / Chapter 1.2 --- Parallel Computation Approaches --- p.2 / Chapter 1.3 --- Architecture Issues --- p.2 / Chapter 1.4 --- Communications --- p.3 / Chapter 1.5 --- Object Oriented Models --- p.4 / Chapter 1.6 --- Parallel Objects --- p.5 / Chapter 1.7 --- Related Works --- p.6 / Chapter 1.7.1 --- Actor Model --- p.6 / Chapter 1.7.2 --- Nested Object --- p.7 / Chapter 1.7.3 --- Nested Transaction --- p.7 / Chapter 1.7.4 --- C++* --- p.8 / Chapter 1.8 --- Summary --- p.8 / Chapter 2 --- Design Issues --- p.10 / Chapter 2.1 --- Goals --- p.11 / Chapter 2.1.1 --- Parallel Model --- p.11 / Chapter 2.1.2 --- Portability --- p.11 / Chapter 2.1.3 --- Class Extension --- p.12 / Chapter 2.2 --- Arguments --- p.12 / Chapter 2.2.1 --- Single versus Multiple Thread Objects --- p.12 / Chapter 2.2.2 --- Active versus Passive Objects --- p.13 / Chapter 2.2.3 --- Synchronous versus Asynchronous Communications --- p.13 / Chapter 2.2.4 --- Architecture Dependence versus Independence --- p.13 / Chapter 2.3 --- Class Structure --- p.14 / Chapter 2.3.1 --- Kernel Class --- p.14 / Chapter 2.3.2 --- Concurrent Class --- p.15 / Chapter 2.3.3 --- Share Class --- p.15 / Chapter 3 --- Execution Model --- p.17 / Chapter 3.1 --- Parallel Objects --- p.19 / Chapter 3.1.1 --- Initialization Phase --- p.19 / Chapter 3.1.2 --- Communication System --- p.21 / Chapter 3.1.3 --- Phase Transition --- p.22 / Chapter 3.1.4 --- Outstanding Requests --- p.24 / Chapter 3.2 --- Concurrent Object --- p.25 / Chapter 3.2.1 --- Service Methods --- p.26 / Chapter 3.2.2 --- Immutable Methods --- p.26 / Chapter 3.2.3 --- Urgent Methods --- p.27 / Chapter 3.2.4 --- Phase Transitional Methods --- p.28 / Chapter 3.2.5 --- Phase Immutable Methods --- p.29 / Chapter 3.3 --- Share Object --- p.30 / Chapter 3.3.1 --- Concurrency Control --- p.31 / Chapter 3.3.2 --- Ticket System --- p.33 / Chapter 3.4 --- Summary --- p.34 / Chapter 4 --- Kernel and Implementation --- p.37 / Chapter 4.1 --- Kernel Components --- p.37 / Chapter 4.1.1 --- Functionality --- p.38 / Chapter 4.1.2 --- Kernel Structure --- p.42 / Chapter 4.1.3 --- Kernel Interface --- p.43 / Chapter 4.1.4 --- Kernel Composition --- p.44 / Chapter 4.2 --- Implementation Issues --- p.46 / Chapter 4.2.1 --- Precompiler --- p.46 / Chapter 4.2.2 --- Object Manager --- p.49 / Chapter 4.2.3 --- Communication System --- p.51 / Chapter 4.2.4 --- Method Invocation --- p.52 / Chapter 4.2.5 --- Restrictions --- p.55 / Chapter 4.3 --- Summary --- p.55 / Chapter 5 --- Evaluation --- p.58 / Chapter 5.1 --- Case Study I --- p.58 / Chapter 5.2 --- Case Study II --- p.63 / Chapter 5.3 --- Overall Evaluation --- p.66 / Chapter 5.4 --- Summary --- p.70 / Chapter 6 --- Conclusion --- p.72 / Chapter A --- ACCEL Header Files --- p.78 / Chapter A.1 --- OBJID.H --- p.78 / Chapter A.2 --- OBJKERN.H --- p.80 / Chapter A.3 --- OBJCONC.H --- p.83 / Chapter A.4 --- OBJSHARE.H --- p.84 / Chapter B --- Case Studies --- p.87 / Chapter B.1 --- Gaussian Elimination --- p.87 / Chapter B.2 --- One Open End Tube --- p.96 / Bibliography --- p.103

In recent years there has been great interest in implementing object recognition frame work on mobile phones. This has stemmed from the fact the advances in object recognition algorithm and mobile phone capabilities have built a congenial ecosystem. Application developers on mobile platforms are trying to utilize the object recognition technology to build better human computer interfaces. This approach is in the nascent phase and proper application framework is required. In this thesis, we propose a framework to overcome design challenges and provide an evaluation methodology to assess the system performance. We use the emerging Android mobile platform to implement and test the framework. We performed a case study using the proposal and reported the test result. This assessment will help developers make wise decisions about their application design. Furthermore, the Android API developers could use this information to provide better interfaces to the third party developers. The design and evaluation methodology could be extended to other mobile platforms for a wider consumer base. / by Vivek Kumar Tyagi. / Thesis (M.S.C.S.)--Florida Atlantic University, 2010. / Includes bibliography. / Electronic reproduction. Boca Raton, Fla., 2010. Mode of access: World Wide Web.

The object-oriented community is paying increasing attention to techniques for object instance encapsulation and alias protection. Formal techniques for modular verification of programs at the level of objects are being developed hand in hand with type systems and static analysis techniques for restricting the structure of runtime object graphs. Ownership type systems have provided a sound basis for such structural restrictions by being able to statically represent an extensible object ownership hierarchy. However, such structural restrictions may potentially have limitations on cases when more flexible reference structures are desired. In this thesis, we present a different encapsulation technique, called Effect Encapsulation, which confines side effects rather than object references. With relaxed restriction on reference structure, it is able to express certain common object-oriented patterns which cannot be expressed in Ownership Types. From this basis, we also describe a model of Object Validity --- a framework for reasoning about object invariants. Such a framework can track the effect and dependency of method calls on object invariants within an ownership-based type system, even in the presence of re-entrant calls. Moreover, we present an access control technique for protecting object instances. Combined with context variance, the resulting type system allows for a more flexible and useful access control policy, hence is capable of expressing more object-oriented patterns.

Object - oriented ecosystem modelling was introduced in the early of 1990s ( Silvert, 1992 ). From that time on, ecosystem models using object - oriented programming ( OOP ) has earned significant achievements with increasing upgraded information technology. The common purposes of ecosystem modellers are to build a model with flexible structure, which allow continuous modifications on the model content. In last decade, ecosystem modellers have put a large number of efforts to practice the OOP approaches in order to implement a true object - oriented ecosystem model. However, these previous work have not fully take advantage of object - orientation because of misusing more or less this technique. This paper explains the shortcoming of these previous endeavours therewith points out a practical solution that using the methodology of object - oriented software engineering and some relative novel information techniques. A case study SALMO - OO will be presented in this paper to prove Silvert ' s assumption that OOP play an important role on ecosystem modelling approaches. Moreover, the results of SALMO - OO convince that object - oriented ecosystem modelling can be achieved by using object - oriented software engineering associating with a true object - oriented programming language ( Java in this case ). / Thesis (M.Sc.)--School of Earth and Environmental Sciences, 2006.

One of the commonly used simulation approaches is process orientation. This is based on the use of nodes (or blocks) that perform functions in series. In spite of the compactness and ease of learning that characterize process-based simulation, many languages are somewhat complex, primarily the result of the large number of nodes that users have to deal with and the considerable gulf between a user's abstract notion of the model and the details required to implement it. This paper describes a process-based simulation system that integrates object-oriented programming, visual interactive simulation and graphical model specification. Object-oriented programming techniques and simulation seem to be a natural match. The process classes are represented as network blocks or network nodes, and the process as a network diagram or directed graph. Arcs connect the nodes and specify the next step in the process. Each block type has its own icon. Developing an application model requires selecting a set of nodes, connecting them, and specifying the parameters (such as activity durations and random number streams) of the nodes through dialog boxes or inspection panels. Nodes have been designed to accomplish the major requirements in simulation modeling, including creation and termination of entities, attribute assignment, branching, queues and resources, activity specification and statistics collection and display. Additional system features include: statistics manipulation for steady state results, execution trace utilities, and limited animation capabilities. The system has been implemented for the NeXT programming environment using Objective-C. The NeXT includes an extensive object-oriented user interface library, relatively powerful hardware, and a modern multi-tasking and virtual memory operating system. Objective-C allows object-oriented concepts such as inheritance and subclassing while adding only a few constructs to that of the C language. The system modeling environment developed in this research enhances the applicability and usability of high level modeling tools. The program also provides a platform for further work on the distribution of the modeling process over several cooperating, communicating applications. / Graduation date: 1992

S3 (Softwood Sawmill Simulator) is a sawmill simulation system for modeling the operations of Pacific Northwest softwood lumber mills. S3 consists of three main parts. The first part is the framework for construction of the sawmill layout. The second part focuses on individual machine centers, their process and down times, and their interconnections. The third part consists of databases for raw material and final products. S3 inputs process logic from external data files. All parts are integrated in an object-oriented framework. The system was developed using the object-oriented environment, Actor. All data input and output are through database files in dBASE IV format. S3 can model a sawmill represented by the machine center and connection types defined in S3. The size of the model is controlled by the Actor programming environment. The construction of a sawmill model is demonstrated. / Graduation date: 1993