From Object-Oriented Specification to Implementation: A Formal Refinement Methodology.

Traditionally, software development models use different methods and techniques in each phase from specification through design to implementation. Significant changes in the representations between phases have been common. The formal development method based on formal specification and stepwise development has been suggested to reduce the change in representation. The formal development method consists of a formal specification and verified design. In the formal specification step, a formal specification language is used to specify an accurate, consistent, and complete system. Vienna Development Method (VDM) is one of the most widely used formal specification languages. A verified design guides the development of the system from specification to executable code. A refinement method is used in VDM for that purpose. The use of the object-oriented paradigm is another important trend in software engineering. Initially, object-oriented methods were applied primarily during the implementation phase using object-oriented languages. Eiffel is an object-oriented programming language which has many strong facilities such as assertions and genericity. Numerous object-oriented specification languages exist, including object-oriented extensions to VDM. We defined Object-VDM to help remove limitations from existing object-oriented VDM languages. In this dissertation, we investigate a formal development method in the object-oriented environment since limited research hss been done in the area. We defined a refinement method that refines an Object-VDM specification to Eiffel code. There are three stages in this refinement: data refinement, operation refinement, and structure refinement. In data refinement, the mathematical data models in Object-VDM are converted to Eiffel data structures by creating Eiffel libraries. We proved the correctness of the conversion. In operation refinement, we modified and added rules to the original refinement to obtain Eiffel code. Object-oriented features are converted in the structure refinement step. In summary, this research provides a refinement method in object-oriented environments. Specifically, the refinement converts Object-VDM specifications to Eiffel codes

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

Metamodel-based model conformance and multiview consistency checking

Model-driven development, using languages such as UML and BON, often makes use of multiple diagrams (e.g., class and sequence diagrams) when modeling systems. These diagrams, presenting different views of a system of interest, may be inconsistent. A metamodel provides a unifying framework in which to ensure and check consistency, while at the same time providing the means to distinguish between valid and invalid models, that is, conformance. Two formal specifications of the metamodel for an object-oriented modeling language are presented, and it is shown how to use these specifications for model conformance and multiview consistency checking. Comparisons are made in terms of completeness and the level of automation each provide for checking multiview consistency and model conformance. The lessons learned from applying formal techniques to the problems of metamodeling, model conformance, and multiview consistency checking are summarized

Contract-Based General-Purpose GPU Programming

Using GPUs as general-purpose processors has revolutionized parallel computing by offering, for a large and growing set of algorithms, massive data-parallelization on desktop machines. An obstacle to widespread adoption, however, is the difficulty of programming them and the low-level control of the hardware required to achieve good performance. This paper suggests a programming library, SafeGPU, that aims at striking a balance between programmer productivity and performance, by making GPU data-parallel operations accessible from within a classical object-oriented programming language. The solution is integrated with the design-by-contract approach, which increases confidence in functional program correctness by embedding executable program specifications into the program text. We show that our library leads to modular and maintainable code that is accessible to GPGPU non-experts, while providing performance that is comparable with hand-written CUDA code. Furthermore, runtime contract checking turns out to be feasible, as the contracts can be executed on the GPU

Encapsulation and Aggregation

A notion of object ownership is introduced as a solution to difficult problems of specifying and reasoning about complex linked structures and of modeling aggregates (composit objects). Syntax and semantics are provided for extending Eiffel with language support for object ownership annotation and checking. The ideas also apply to other OOPLs such as C++