OOPS-Algol :an extension to PS-Algol to support object-orientated programming : a thesis presented in partial fulfilment of the requirements for the degree of Master of Science at Massey University

Object-oriented programming is becoming a widely accepted paradigm to promote software reuse and data abstraction. Many languages are having object oriented capabilities added to them. PS-Algol is a language which supports procedures as first class data, and supports orthogonality of per­sistence. OOPS-Algol extends the PS-Algol language to support object-oriented programming. OOPS-Algol is different from most other object­ oriented languages in that it explicitly separates the implementation of a class's protocol from the descrip­tion of that protocol. The class hierarchy is used solely for defining the conceptual relationships between classes. The inheritance hierarchy is used to promote code sharing, without being constrained by the class hierarchy. This capability furthers progress towards the goal of separating the conceptual design of a system from its implementation

Applying inspection to object-oriented software

The benefits of the object-oriented paradigmare widely cited. At the same time, inspection is deemed to be the most cost-effective means of detecting defects in software products. Why then, is there no published experience, let alone quantitative data, on the application of inspection to object-oriented systems? We describe the facilities of the object-oriented paradigm and the issues that these raise when inspecting object-oriented code. Several problems are caused by the disparity between the static code structure and its dynamic runtime behaviour. The large number of small methods in object-oriented systems can also cause problems. We then go on to describe three areas which may help mitigate problems found. Firstly, the use of various programming methods may assist in making object-oriented code easier to inspect. Secondly, improved program documentation can help the inspector understand the code which is under inspection. Finally, tool support can help the inspector to analyse the dynamic behaviour of the code. We conclude that while both the object-oriented paradigm and inspection provide excellent benefits on their own, combining the two may be a difficult exercise, requiring extensive support if it is to be successful

A Constrained Object Model for Configuration Based Workflow Composition

Automatic or assisted workflow composition is a field of intense research for applications to the world wide web or to business process modeling. Workflow composition is traditionally addressed in various ways, generally via theorem proving techniques. Recent research observed that building a composite workflow bears strong relationships with finite model search, and that some workflow languages can be defined as constrained object metamodels . This lead to consider the viability of applying configuration techniques to this problem, which was proven feasible. Constrained based configuration expects a constrained object model as input. The purpose of this document is to formally specify the constrained object model involved in ongoing experiments and research using the Z specification language.Comment: This is an extended version of the article published at BPM'05, Third International Conference on Business Process Management, Nancy Franc

Designing Software Architectures As a Composition of Specializations of Knowledge Domains

This paper summarizes our experimental research and software development activities in designing robust, adaptable and reusable software architectures. Several years ago, based on our previous experiences in object-oriented software development, we made the following assumption: ‘A software architecture should be a composition of specializations of knowledge domains’. To verify this assumption we carried out three pilot projects. In addition to the application of some popular domain analysis techniques such as use cases, we identified the invariant compositional structures of the software architectures and the related knowledge domains. Knowledge domains define the boundaries of the adaptability and reusability capabilities of software systems. Next, knowledge domains were mapped to object-oriented concepts. We experienced that some aspects of knowledge could not be directly modeled in terms of object-oriented concepts. In this paper we describe our approach, the pilot projects, the experienced problems and the adopted solutions for realizing the software architectures. We conclude the paper with the lessons that we learned from this experience

Extracting Object Oriented Software Architecture from C++ Source Code

Software architecture strongly influences the ability to satisfy quality attributes such as modifiability, performance, and security. It is important to be able to analyse and extract information about that architecture. However, architectural documentation frequently does not exist, and when it does, it is often out of sync with the implemented system. In addition, it is not all that software development begins with a clean slate; systems are almost always constrained by the existing legacy code. As a consequence, there is a need to extract information from existing system implementations and reason architecturally about this information. This research presents a reverse engineering tool VOO++ that will read an Object- Oriented C++ source code using UML notation in order to visualise its Class structure and the various relationships that may exist including, inheritance, aggregation, and dependency relationships based on the modified Cohen-Sutherland clipping algorithm. The idea of clipping is reversed, instead of clipping inside the rectangle, the clipping is done out side the rectangle in terms of four directions (left, right, top, and bottom) and two points represent the centre point for each rectangle. An Object-Oriented approach is used to design and implement the tool. Reverse engineering, design pattern, and graphics are the underlying techniques supplied. VOO++ aids an analyst in extracting, manipulating and interpreting the Object-Oriented static model information. By assisting in the reconstruction of static architectures from extracted information, VOO++ helps an analyst to redocument and understand architectures and discover the relationship between "as-implemented" and "asdesigned" architectures

Abstracting object interactions using composition filters

It is generally claimed that object-based models are very suitable for building distributed system architectures since object interactions follow the client-server model. To cope with the complexity of today's distributed systems, however, we think that high-level linguistic mechanisms are needed to effectively structure, abstract and reuse object interactions. For example, the conventional object-oriented model does not provide high-level language mechanisms to model layered system architectures. Moreover, we consider the message passing model of the conventional object-oriented model as being too low-level because it can only specify object interactions that involve two partner objects at a time and its semantics cannot be extended easily. This paper introduces Abstract Communication Types (ACTs), which are objects that abstract interactions among objects. ACTs make it easier to model layered communication architectures, to enforce the invariant behavior among objects, to reduce the complexity of programs by hiding the interaction details in separate modules and to improve reusability through the application of object-oriented principles to ACT classes. We illustrate the concept of ACTs using the composition filters model

The C++0x "Concepts" Effort

C++0x is the working title for the revision of the ISO standard of the C++ programming language that was originally planned for release in 2009 but that was delayed to 2011. The largest language extension in C++0x was "concepts", that is, a collection of features for constraining template parameters. In September of 2008, the C++ standards committee voted the concepts extension into C++0x, but then in July of 2009, the committee voted the concepts extension back out of C++0x. This article is my account of the technical challenges and debates within the "concepts" effort in the years 2003 to 2009. To provide some background, the article also describes the design space for constrained parametric polymorphism, or what is colloquially know as constrained generics. While this article is meant to be generally accessible, the writing is aimed toward readers with background in functional programming and programming language theory. This article grew out of a lecture at the Spring School on Generic and Indexed Programming at the University of Oxford, March 2010