104,304 research outputs found
Transformation of UML interaction diagrams into contract specifications for object-oriented testing
Testing is an important means to ensure the quality of software systems. Contract specification can be used to formally specify the cluster level of object-oriented software, which can then be tested using TACCLE, an advanced methodology for object-oriented testing. The use of formal specifications as a testing base has many advantages. However, such specifications are not easily understood and therefore not widely used in the software industry. On the other hand, UML, a semi-formal modeling language, is becoming increasingly popular and widely accepted. In particular, UML interaction diagrams specify the dynamic, interacting behavior among the objects of an object-oriented system. If the transformation of UML interaction diagrams into Contract specifications can be automated, the TACCLE methodology can be applied directly to test object-oriented software at the cluster level. In this paper, a method to transform UML interaction diagrams into Contract specifications is proposed based on the UML meta-model. A prototype has been developed. © 2007 IEEE.published_or_final_versio
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
Deductive verification of object-oriented software : dynamic frames, dynamic logic and predicate abstraction
Software systems play a central role in modern society, and their correctness is often crucially important. Formal specification and verification are promising approaches for ensuring correctness more rigorously than just by testing. This work presents an approach for deductively verifying design-by-contract specifications of object-oriented programs. The approach is based on dynamic logic, and addresses the challenges of modularity and automation using dynamic frames and predicate abstraction
Topics in Cement and Concrete Research
In recent decades, the construction sector has faced many changes. One of these changes is the shift in the role of national government from one-sided practices in which the government was solely responsible for strategic and long-term spatial planning to a multi-actor and multi-level arena. One outcome was a rearrangement of the balance between public and private responsibilities. This has led to new procurement routes and contracts as Private Finance Initiative (PFI) and Public Private Partnerships (PPP), as well as to a more performance-oriented client (both public and private). At the same time, construction firms changed their strategic focus from cost efficiency to adding value for money for the client, resulting in new contract forms such as Design & Construct (D&C), Building, Operate & Transfer (BOT) and variants there from. So far, governments of most European countries have their own restrictive specifications for the use of building materials
Object-oriented Programming Laws for Annotated Java Programs
Object-oriented programming laws have been proposed in the context of
languages that are not combined with a behavioral interface specification
language (BISL). The strong dependence between source-code and interface
specifications may cause a number of difficulties when transforming programs.
In this paper we introduce a set of programming laws for object-oriented
languages like Java combined with the Java Modeling Language (JML). The set of
laws deals with object-oriented features taking into account their
specifications. Some laws deal only with features of the specification
language. These laws constitute a set of small transformations for the
development of more elaborate ones like refactorings
Software Support for Industrial Controls Contract
The contract covers the development and the operation and maintenance (O&M) of the monitoring and control systems used for supervising CERN's technical infrastructure. The contract involves those responsible for equipment in any current or future technical installation. We are outsourcing a complex activity which will require efforts on both preparing the specifications for new projects and setting clear definitions of tasks and procedures for O&M. It is a result-oriented contract in which performance will be continually evaluated by different methods and tools: project management plan and project follow-up, and CAMMS (Computerised Assets and Maintenance Management system). To be used effectively, this approach requires complete traceability of activities and documentation of the systems. Based on the analysis of the results measured and the shared (CERN and contractor) experience, the O&M activities will be reviewed and reorganised and operational procedures will be changed according to needs. A key issue of this contract is the challenge of establishing a good partnership with the contractor in order to reach the goals
Unifying Requirements and Code: an Example
Requirements and code, in conventional software engineering wisdom, belong to
entirely different worlds. Is it possible to unify these two worlds? A unified
framework could help make software easier to change and reuse. To explore the
feasibility of such an approach, the case study reported here takes a classic
example from the requirements engineering literature and describes it using a
programming language framework to express both domain and machine properties.
The paper describes the solution, discusses its benefits and limitations, and
assesses its scalability.Comment: 13 pages; 7 figures; to appear in Ershov Informatics Conference, PSI,
Kazan, Russia (LNCS), 201
Towards correct-by-construction product variants of a software product line: GFML, a formal language for feature modules
Software Product Line Engineering (SPLE) is a software engineering paradigm
that focuses on reuse and variability. Although feature-oriented programming
(FOP) can implement software product line efficiently, we still need a method
to generate and prove correctness of all product variants more efficiently and
automatically. In this context, we propose to manipulate feature modules which
contain three kinds of artifacts: specification, code and correctness proof. We
depict a methodology and a platform that help the user to automatically produce
correct-by-construction product variants from the related feature modules. As a
first step of this project, we begin by proposing a language, GFML, allowing
the developer to write such feature modules. This language is designed so that
the artifacts can be easily reused and composed. GFML files contain the
different artifacts mentioned above.The idea is to compile them into FoCaLiZe,
a language for specification, implementation and formal proof with some
object-oriented flavor. In this paper, we define and illustrate this language.
We also introduce a way to compose the feature modules on some examples.Comment: In Proceedings FMSPLE 2015, arXiv:1504.0301
- …