Strategic Directions in Object-Oriented Programming

This paper has provided an overview of the field of object-oriented programming. After presenting a historical perspective and some major achievements in the field, four research directions were introduced: technologies integration, software components, distributed programming, and new paradigms. In general there is a need to continue research in traditional areas:\ud (1) as computer systems become more and more complex, there is a need to further develop the work on architecture and design; \ud (2) to support the development of complex systems, there is a need for better languages, environments, and tools; \ud (3) foundations in the form of the conceptual framework and other theories must be extended to enhance the means for modeling and formal analysis, as well as for understanding future computer systems

Web System to Support the Teaching of an Undergraduate Distributed Systems Course

This paper introduces a web-based system that supports the teaching of an undergraduate (UG) distributed systems course. It specifically describes a web system that was developed to complement the functionality of web objects in the XML (WOX) framework. It allows for storing and visualizing the state of distributed objects, as well as displaying and executing methods through a web interface. Users can provide values for each of the parameters. The WOX framework is essential to note as it facilitates the development of distributed applications that are object-based and can interoperate among different object-oriented programming languages. WOX employs the XML format to represent objects and uses HTTP as the communication protocol

A Formal Methodology for the Specification of Distributed Systems From an Object Perspective.

Distributed computing systems are systems in which multiple processors run independently by communicating with each other. The design of distributed systems is difficult to achieve as the execution patterns of distributed system are typically more complex than those of non-distributed computing systems. The application of object-oriented techniques to the design of distributed systems has the potential to increase the power of modeling and computing. A formal methodology which includes a specification language, developed from an object perspective, for the development of distributed systems is presented. The formal specification language, DOSL (Distributed Object-based Specification Language), represents the specification of distributed systems from an object perspective. DOSL has a hybrid format which combines the property-oriented approach and the model-oriented approach. In particular, it has strong features for message passing specification. The semantics of DOSL is defined formally by two operational semantics methods: transition systems and Petri nets. In addition, a formal object-based methodology for the specification of distributed systems is given. The methodology presents a framework for using the DOSL specification language and includes an integrated formalized method for identification of objects, their operations and behaviors from multiple modeling formats. The implementation of the methodology is supported by assistance with a knowledge base

Design and implementation of a distance education system aimed to the teaching of object-oriented technologies

In the new connected and distributed electronic world, the object-orientation (00) paradigm has been recognized as a strategy for software development, based on the idea of producing systems starting from reusable components. Problems of the rea1 world are easier to be dea1t with when 00 developrnent approach is used than when the structured and traditiona1 one is applied. In the software engineering cornmunity, the question of rnanaging changes has been a permanent concern arnong the developers who look forward to flexible and reusable systems. In this paper , we present a description of a flexible framework, aimed to peer-to-peer applications, that can be plugged-in a distance education platform. This framework is the hosting of a remote computerbased learning system (called TOOHELP). TOOHELP aims the learning of object-oriented techniques: it focuses on a faster development of complex software of high quality. Basically, the TOOHELP utilizes a simplified 00 meta model and it follows a process pattem that unifies the most known patterns of process in use today

EIES 2 : a distributed architecture for supporting group work

The Computerized Conferencing Center (CCCC) at New Jersey Institute of Technology (NJIT) has been researching on-line group communications for 17 years by developing and studying tools to advance the collective intelligence . The Electronic Information Exchange System 2 (EIES2) provides a research, development and operational environment for distributed computer supported cooperative work (CSCW) systems. The EIES 2 distributed Smalltalk processor provides for rapid prototyping and implementation of muti-media CSCW facilities in the network environment. The Smalltalk support of the object model, and meta-language properties make it ideally suited for incremental development CSCW applications. The EIES2 communication environment supports a decentralized network architecture. Modern standards are used in the implementation of data structures, communication interfaces and database. The EIES2 application layer protocols support use ASN.1 data representation to access to an object-oriented distributed database via X.ROS remote operation services. EIES2 can serve as a foundation on which group work systems may be built and defines protocols that can allow them to inter-operate. An initial system presents a powerful metaphor of conferences and activities which provides an extensible framework upon which to add group work applications. Work to date has provided structures for information exchange, inquiry networking, information filtering, the on-line virtual classroom, and group decision support. This paper presents the system architecture model used for EIES2 and describes the implementation and current applications

Object oriented design and programming for experiment online applications---Experiences with a prototype application

The increase in the variety of computer platforms incorporated into online data acquisition systems at Fermilab compels consideration of how to best design and implement applications to be maintainable, reusable and portable. To this end we have evaluated the applicability to Object Oriented Design techniques, and Object Oriented Programming languages for online applications. We report on this evaluation. We are designing a specific application which provides a framework for experimenters to access and display their raw data on UNIX workstations that form part of their distributed online data acquisition system. We have chosen to implement this using the C++ OOP language. We report on our experiences in object oriented design and lessons learned which we will apply to future software development. 14 refs

A Machine With Class: A Framework for Object Generation, Integration and Language Authentication (FROGILA)

The object technology model is constantly evolving to address the software crisis problem. This novel idea which informed and currently guides the design style of most modern scalable software systems has caused a strong belief that the object-oriented technology is the ultimate answer to the software crisis, i.e. applying an object-oriented development method will eventually lead to quality code. It is important to emphasise that object-orientedness does not make testing obsolete. As a matter of fact, some aspects of its very nature introduce new problems into the production of correct programs and their testing due to paradigmatic features like encapsulation, inheritance, polymorphism and dynamic binding as this research work shows. Most work in testing research has centred on procedure-oriented software with worthwhile methods of testing having been developed as a result. However, those cannot be applied directly to object-oriented software owing to the fact that the architectures of such systems differ on many key issues. In this thesis, we investigate and review the problems introduced by the features of the object technology model and then proceed to show why traditional structured software testing techniques are insufficient for testing object-oriented software by comparing the fundamental differences in their architecture. Also, by reviewing Weyuker’s test adequacy axioms we show that program-based testing and specification-based testing are orthogonal and complementary. Thus, a software testing methodology that is solely based on one of these approaches (i.e. program-based or specification-based testing) cannot adequately cover all the essential paths of the system under test or satisfactorily guarantee correctness in practice. We argue that a new method is required which integrates the benefits of the two approaches and further builds upon their individual strengths to create a more meaningful, practical and reliable solution. To this end, this thesis introduces and discusses a new automaton-based framework formalism for object-oriented classes called the Class-Machine and a test method that is based on this formalism. Here, the notion of a class or the idea behind classification in object-oriented languages is embodied within a machine framework. The Class-Machine model represents a polymorphic abstraction for heterogeneous families of Object-Machines that model a real life problem in a given domain; these Object-Machines are instances of different concrete machine types. The Class-Machine has an extensible machine implementation as well as an extensible machine interface. Thus, the Class-Machine is introduced as a formal framework for generating autonomous Object-Machines (i.e. Object-Machine Generator) that share common Generic Class-Machine States and Specific Object-Machine States. The states of these Object-Machines are manipulated by a set of processing functions (i.e. Class-Machine Methods and Object-Machine Methods) that must satisfy a set of preconditions before they are allowed to modify the state(s) of the Object-Machines. The Class-Machine model can also be viewed as a platform for integrating a society of communicating Object-Machines. To verify and completely test systems that adhere to the Class-Machine framework, a novel testing method is proposed i.e. the fault-finders (f²) - a distributed family of software checkers specifically designed to crawl through a Class-Machine implementation to look for a particular type of fault and tell us the location of the fault in the program (i.e. the class under test). Given this information, we can statistically show the distribution of faults in an object-oriented system and then provide a probabilistic assertion of the number and type of faults that remain undetected after testing is completed. To address the problems caused through the encapsulation mechanism, this thesis introduces and discusses another novel framework formalism that has complete visibility on all the encapsulated methods, memory states of the instance and class variables of a given Object-Machine or Class-Machine system under test. We call this the Class Machine Friend Function (CMƒƒ). In order to further illustrate all the fundamental theoretical ideas and paradigmatic features inherent within our proposed Class-Machine model, this thesis considers four different Class-Machine case studies. Finally, to further show that the Class-Machine theoretical purity does not mitigate against practical concerns, our novel object-oriented specification, verification, debugging and testing approaches proposed in this thesis are exemplified in an automated testing tool called: The Class-Machine Testing Tool (CMTT)

Domain-protocol mapping based middleware for distributed application development, A

2014 Spring.Includes bibliographical references.Distributed systems such as Internet of Things, Sensor Networks and Networked Control Systems are being used in various application domains, including industrial, environmental, medical and energy management domains. A distributed application in these domains may need to access data from different devices, where they may all be of the same type or a combination of different types. In addition, these devices may communicate through standardized protocols or proprietary interfaces. The development of such a distributed application may also require a team of developers with expertise in different disciplines. Therefore, the application development that involves heterogeneous devices and multidisciplinary teams can be made more effective by introducing an interface layer that shields developers from aspects of software and hardware heterogeneity. This work proposes a 'domain-protocol mapping' technique that is implemented as a middleware framework. The proposed mapping method maps the application data schema represented as object-oriented domain object to the appropriate communication protocol packet data and also updates the domain object from the response packet data. The middleware provides APIs for the domain experts to read the data from the device or to write the data to the device. The marshalling and unmarshalling process of the domain objects are hidden from the domain expert who may or may not be a software engineer. The use of the developed middleware is illustrated in two case-studies, one involving a simulation of distributed network controls for power system and the other involving integration of different types of power meters in power monitoring application

Building object-oriented software with the D-Bus messaging system

Object-oriented programming is a widely adopted paradigm for desktop software development. This paradigm partitions software into separate entities, objects, which consist of data and related procedures used to modify and inspect it. The paradigm has evolved during the last few decades to emphasize decoupling between object implementations, via means such as explicit interface inheritance and event-based implicit invocation. Inter-process communication (IPC) technologies allow applications to interact with each other. This enables making software distributed across multiple processes, resulting in a modular architecture with benefits in resource sharing, robustness, code reuse and security. The support for object-oriented programming concepts varies between IPC systems. This thesis is focused on the D-Bus system, which has recently gained a lot of users, but is still scantily researched. D-Bus has support for asynchronous remote procedure calls with return values and a content-based publish/subscribe event delivery mechanism. In this thesis, several patterns for method invocation in D-Bus and similar systems are compared. The patterns that simulate synchronous local calls are shown to be dangerous. Later, we present a state-caching proxy construct, which avoids the complexity of properly asynchronous calls for object inspection. The proxy and certain supplementary constructs are presented conceptually as generic object-oriented design patterns. The e ect of these patterns on non-functional qualities of software, such as complexity, performance and power consumption, is reasoned about based on the properties of the D-Bus system. The use of the patterns reduces complexity, but maintains the other qualities at a good level. Finally, we present currently existing means of specifying D-Bus object interfaces for the purposes of code and documentation generation. The interface description language used by the Telepathy modular IM/VoIP framework is found to be an useful extension of the basic D-Bus introspection format.Siirretty Doriast