Formal Approaches to Systems Analysis Using UML

2002 ◽  
pp. 324-341
Author(s):  
Jonathan Whittle
Keyword(s):  
Formal Methods ◽  
Development Strategy ◽  
Ad Hoc ◽  
Formal Analysis ◽  
Daily Basis ◽  
Software Systems ◽  
Industry Standard ◽  
Mathematical Techniques ◽  
Software Lifecycle ◽  
Modeling Level

Formal methods, whereby a system is described and/or analyzed using precise mathematical techniques, is a well-established and yet, under-used approach for developing software systems. One of the reasons for this is that project deadlines often impose an unsatisfactory development strategy in which code is produced on an ad hoc basis without proper thought about the requirements and design of the piece of software in mind. The result is a large, often poorly documented and un-modular monolith of code that does not lend itself to formal analysis. Because of their complexity, formal methods work best when code is well structured, e.g., when they are applied at the modeling level. UML is a modeling language that is easily learned by system developers and, more importantly, an industry standard, which supports communication between the various project stakeholders. The increased popularity of UML provides a real opportunity for formal methods to be used on a daily basis within the software lifecycle. Unfortunately, the lack of precision of UML means that many formal techniques cannot be applied directly. If formal methods are to be given the place they deserve within UML, a more precise description of UML must be developed. This chapter surveys recent attempts to provide such a description, as well as techniques for analyzing UML models formally.

scholarly journals Formal Analysis and Verification of Airborne Software Based on DO-333

Electronics ◽  
2020 ◽  
Vol 9 (2) ◽  
pp. 327
Author(s):  
Zongyu Cao ◽  
Wanyou Lv ◽  
Yanhong Huang ◽  
Jianqi Shi ◽  
Qin Li
Keyword(s):  
Formal Methods ◽  
Formal Analysis ◽  
Practical Application ◽  
Practical Applications ◽  
Technological Advances ◽  
Catastrophic Loss ◽  
Development Processes ◽  
General Guide ◽  
Verification Process ◽  
Software Lifecycle

With rapid technological advances in airborne control systems, it has become imperative to ensure the reliability, robustness, and adaptability of airborne software since failure of these software could result in catastrophic loss of property and life. DO-333 is a supplement to the DO-178C standard, which is dedicated to guiding the application of formal methods in the review and analysis of airborne software development processes. However, DO-333 lacks theoretical guidance on how to choose appropriate formal methods and tools to achieve verification objectives at each stage of the verification process, thereby limiting their practical application. This paper is intended to illustrate the formal methods and tools available in the verification process to lay down a general guide for the formal development and verification of airborne software. We utilized the Air Data Computer (ADC) software as the research object and applied different formal methods to verify software lifecycle artifacts. This example explains how to apply formal methods in practical applications and proves the effectiveness of formal methods in the verification of airborne software.

Formal Methods for the Development and Verification of Autonomic IT Systems

2011 ◽  
pp. 1-37 ◽  
Author(s):  
Radu Calinescu ◽  
Shinji Kikuchi ◽  
Marta Kwiatkowska
Keyword(s):  
Formal Methods ◽  
Formal Specification ◽  
Autonomic Computing ◽  
Ad Hoc ◽  
Conflict Detection ◽  
It Systems ◽  
Challenges And Opportunities ◽  
Quantitative Verification ◽  
Mathematical Techniques

This chapter explores ways in which rigorous mathematical techniques, termed formal methods, can be employed to improve the predictability and dependability of autonomic computing. Model checking, formal specification, and quantitative verification are presented in the contexts of conflict detection in autonomic computing policies, and of implementation of goal and utility-function policies in autonomic IT systems, respectively. Each of these techniques is illustrated using a detailed case study, and analysed to establish its merits and limitations. The analysis is then used as a basis for discussing the challenges and opportunities of this endeavour to transition the development of autonomic IT systems from the current practice of using ad-hoc methods and heuristic towards a more principled approach.

scholarly journals Balancing the formal and the informal in user-centred design

2021 ◽  
Author(s):  
Michael D Harrison ◽  
Paolo Masci ◽  
José Creissac Campos
Keyword(s):  
Formal Methods ◽  
Systematic Approach ◽  
Formal Analysis ◽  
Interactive Systems ◽  
User Evaluation ◽  
Analysis Techniques ◽  
User Centred Design ◽  
Early Design Stages ◽  
Cooperative Evaluation

Abstract This paper explores the role of formal methods as part of the user-centred design of interactive systems. An iterative process is described, developing prototypes incrementally, proving user-centred requirements while at the same time evaluating the prototypes that are executable forms of the developed models using ‘traditional’ techniques for user evaluation. A formal analysis complements user evaluations. This approach enriches user-centred design that typically focuses understanding on context and producing sketch designs. These sketches are often non-functional (e.g. paper) prototypes. They provide a means of exploring candidate design possibilities using techniques such as cooperative evaluation. This paper describes a further step in the process using formal analysis techniques. The use of formal methods provides a systematic approach to checking plausibility and consistency during early design stages, while at the same time enabling the generation of executable prototypes. The technique is illustrated through an example based on a pill dispenser.

scholarly journals Modelling Software Architecture for Visual Simultaneous Localization and Mapping

Automation ◽  
2021 ◽  
Vol 2 (2) ◽  
pp. 48-61
Author(s):  
Bhavyansh Mishra ◽  
Robert Griffin ◽  
Hakki Erhan Sevil
Keyword(s):  
System Integration ◽  
Ad Hoc ◽  
Simultaneous Localization And Mapping ◽  
Software Systems ◽  
Model Driven ◽  
Performance Improvements ◽  
Software Model ◽  
Localization And Mapping ◽  
Stereo Cameras ◽  
Core Components

Visual simultaneous localization and mapping (VSLAM) is an essential technique used in areas such as robotics and augmented reality for pose estimation and 3D mapping. Research on VSLAM using both monocular and stereo cameras has grown significantly over the last two decades. There is, therefore, a need for emphasis on a comprehensive review of the evolving architecture of such algorithms in the literature. Although VSLAM algorithm pipelines share similar mathematical backbones, their implementations are individualized and the ad hoc nature of the interfacing between different modules of VSLAM pipelines complicates code reuseability and maintenance. This paper presents a software model for core components of VSLAM implementations and interfaces that govern data flow between them while also attempting to preserve the elements that offer performance improvements over the evolution of VSLAM architectures. The framework presented in this paper employs principles from model-driven engineering (MDE), which are used extensively in the development of large and complicated software systems. The presented VSLAM framework will assist researchers in improving the performance of individual modules of VSLAM while not having to spend time on system integration of those modules into VSLAM pipelines.

scholarly journals Multilingual practices in late medieval Swedish writing

2020 ◽  
Vol 71 (2) ◽  
pp. 231-252
Author(s):  
Steffen Höder
Keyword(s):  
Ad Hoc ◽  
Daily Basis ◽  
Point Of View ◽  
Late Medieval ◽  
Low German ◽  
Text Production ◽  
Old Swedish ◽  
Swedish Text ◽  
Regional Languages

Abstract Late medieval Sweden was a multilingual society. At least three languages ‐ namely Old Swedish, Low German, and Latin ‐ were in use, beside other regional languages. While the influence of Low German is easily detectable in all parts of the Swedish language system and has been investigated rather thoroughly from a historical sociolinguistic point of view (cf. Braunmüller 2004), the role of Latin has been rather marginalized in traditional Swedish language historiography, focusing on the earlier stages of Old Swedish, which are described as its classical form (cf. Pettersson 2005). Starting out as the language of religion, administration, diplomacy and, to some extent, trade, Latin was the dominant language of text production in Sweden until the 14th century, which saw Written Old Swedish gain some domains as well, resulting in a more balanced diglossic relation between the two languages. The emerging written variety of Swedish, however, was heavily influenced by the multilingual practices of scribes, in large part clerics who were used to using at least Swedish and Latin on a daily basis for a variety of communicative purposes (Höder 2010). These multilingual practices, ranging from ad hoc translations via code-switching to the application of Latin stylistic, textual, and syntactic norms in Swedish text production (Höder 2018), had a lasting impact on the later development of a Swedish proto-standard, and are still reflected in conservative text types today. This contribution approaches this development from a historical sociolinguistic and contact linguistic perspective, concentrating on the establishment of multilingual practices.

scholarly journals Industrial hardware and software verification with ACL2

2017 ◽  
Vol 375 (2104) ◽  
pp. 20150399 ◽  
Author(s):  
Warren A. Hunt ◽  
Matt Kaufmann ◽  
J Strother Moore ◽  
Anna Slobodova
Keyword(s):  
Programming Language ◽  
Software Verification ◽  
Formal Analysis ◽  
Shared Vision ◽  
Theorem Prover ◽  
Software Systems ◽  
Levels Of Abstraction ◽  
Quarter Century ◽  
Industrial Use ◽  
Technical Features

The ACL2 theorem prover has seen sustained industrial use since the mid-1990s. Companies that have used ACL2 regularly include AMD, Centaur Technology, IBM, Intel, Kestrel Institute, Motorola/Freescale, Oracle and Rockwell Collins. This paper introduces ACL2 and focuses on how and why ACL2 is used in industry. ACL2 is well-suited to its industrial application to numerous software and hardware systems, because it is an integrated programming/proof environment supporting a subset of the ANSI standard Common Lisp programming language. As a programming language ACL2 permits the coding of efficient and robust programs; as a prover ACL2 can be fully automatic but provides many features permitting domain-specific human-supplied guidance at various levels of abstraction. ACL2 specifications and models often serve as efficient execution engines for the modelled artefacts while permitting formal analysis and proof of properties. Crucially, ACL2 also provides support for the development and verification of other formal analysis tools. However, ACL2 did not find its way into industrial use merely because of its technical features. The core ACL2 user/development community has a shared vision of making mechanized verification routine when appropriate and has been committed to this vision for the quarter century since the Computational Logic, Inc., Verified Stack. The community has focused on demonstrating the viability of the tool by taking on industrial projects (often at the expense of not being able to publish much). This article is part of the themed issue ‘Verified trustworthy software systems’.

Measuring the Progress of a System Development

2014 ◽  
pp. 1415-1439
Author(s):  
Marta (Plaska) Olszewska ◽  
Marina Waldén
Keyword(s):  
Formal Methods ◽  
Design Process ◽  
Formal Specification ◽  
System Development ◽  
Structural Complexity ◽  
Software Systems ◽  
System Construction ◽  
Design Decisions ◽  
And Control

For most of the developers and managers, the structure and the behaviour of software systems represented in a graphical manner is more understandable than a formal specification of a system or than plain code. Our previous work combined the intuitiveness of UML with the development rigour brought by formal methods and created progress diagrams. In progress diagrams, the design decisions within a system refinement chain are assisted by the application of patterns and illustrated in a comprehensible and compact manner. In order to rigorously assess and control the design process, we need to thoroughly monitor it. In this chapter we show how the application of generic refinement patterns is reflected in measurements. We establish measures for the evaluation of the design progress of the system, where the progress diagrams are assessed from the size and structural complexity perspective. Our motivation is to support the system developers and managers in making the design decisions that regard the system construction.

Dynamically Reconfigurable Architectures

2014 ◽  
pp. 26-43
Author(s):  
Marek Rychly
Keyword(s):  
Ad Hoc ◽  
Reconfigurable Architectures ◽  
Software Systems ◽  
Actual State ◽  
Dynamically Reconfigurable ◽  
Component Models

Dynamic aspects of behavior of software systems in dynamically reconfigurable runtime architectures can result in significant architectural violations during runtime. In such cases, a system's architecture evolves during the runtime according to the actual state of the system's environment, and consequently, runtime reconfigurations may eventually lead to incorrect architecture configurations that were not considered during the system's design phases. These architectural violations are known as architectural erosion or architectural drift, and they contribute to an increasing brittleness of the system, or a lack of its coherence and clarity of its form. This chapter describes and compares possible measures to prevent architectural violations in dynamic service and component models. The aim of this chapter is to evaluate the applicability of those measures in combination with advanced features of reconfigurable runtime architectures such as ad hoc reconfiguration, service or component mobility, composition hierarchy preservation, and architectural aspects.

Sign in / Sign up

Export Citation Format

Share Document