Modelling an Aircraft Landing System in Event-B (Full Report)

The failure of hardware or software in a critical system can lead to loss of lives. The design errors can be main source of the failures that can be introduced during system development process. Formal techniques are an alternative approach to verify the correctness of critical systems, overcoming limitations of the traditional validation techniques such as simulation and testing. The increasing complexity and failure rate brings new challenges in the area of verification and validation of avionic systems. Since the reliability of the software cannot be quantified, the \textit{correct by construction} approach can implement a reliable system. Refinement plays a major role to build a large system incrementally from an abstract specification to a concrete system. This paper contributes as a stepwise formal development of the landing system of an aircraft. The formal models include the complex behaviour, temporal behaviour and sequence of operations of the landing gear system. The models are formalized in Event-B modelling language, which supports stepwise refinement. This case study is considered as a benchmark for techniques and tools dedicated to the verification of behavioural properties of systems. The report is the full version of a paper published for the ABZ 2014 Case Study. i

Variability Abstractions: Trading Precision for Speed in Family-Based Analyses (Extended Version)

Family-based (lifted) data-flow analysis for Software Product Lines (SPLs) is capable of analyzing all valid products (variants) without generating any of them explicitly. It takes as input only the common code base, which encodes all variants of a SPL, and produces analysis results corresponding to all variants. However, the computational cost of the lifted analysis still depends inherently on the number of variants (which is exponential in the number of features, in the worst case). For a large number of features, the lifted analysis may be too costly or even infeasible. In this paper, we introduce variability abstractions defined as Galois connections and use abstract interpretation as a formal method for the calculational-based derivation of approximate (abstracted) lifted analyses of SPL programs, which are sound by construction. Moreover, given an abstraction we define a syntactic transformation that translates any SPL program into an abstracted version of it, such that the analysis of the abstracted SPL coincides with the corresponding abstracted analysis of the original SPL. We implement the transformation in a tool, reconfigurator that works on Object-Oriented Java program families, and evaluate the practicality of this approach on three Java SPL benchmarks.Comment: 50 pages, 10 figure

Rule-based modeling of biochemical systems with BioNetGen

Totowa, NJ. Please cite this article when referencing BioNetGen in future publications. Rule-based modeling involves the representation of molecules as structured objects and molecular interactions as rules for transforming the attributes of these objects. The approach is notable in that it allows one to systematically incorporate site-specific details about proteinprotein interactions into a model for the dynamics of a signal-transduction system, but the method has other applications as well, such as following the fates of individual carbon atoms in metabolic reactions. The consequences of protein-protein interactions are difficult to specify and track with a conventional modeling approach because of the large number of protein phosphoforms and protein complexes that these interactions potentially generate. Here, we focus on how a rule-based model is specified in the BioNetGen language (BNGL) and how a model specification is analyzed using the BioNetGen software tool. We also discuss new developments in rule-based modeling that should enable the construction and analyses of comprehensive models for signal transduction pathways and similarly large-scale models for other biochemical systems. Key Words: Computational systems biology; mathematical modeling; combinatorial complexity; software; formal languages; stochastic simulation; ordinary differential equations; protein-protein interactions; signal transduction; metabolic networks. 1

The Global Crisis as Digital Transformation Motivator: from Lifecycle Optimization to Efficient Implementation Series

It is generally known that software system development lifecycle (SSDL) should be managed adequately. The global economy crisis and subsequent depression have taught us certain lessons on the subject, which is so vital for digital transformation, for Industry 4.0. The paper presents the adaptive methodology of enterprise SSDL, which allows to avoid local crises while producing large-scale software. The methodology is based on extracting common ERP module level patterns and applying them to series of heterogeneous implementations. The approach includes a lifecycle model, which extends conventional spiral model by formal data representation/management models and DSL-based low-level CASE tools supporting the formalisms. The methodology has been successfully implemented as a series of portal-based ERP systems in ITERA oil-and-gas corporation, and in a number of trading/banking enterprise smart applications for other enterprises. Semantic network-based air traffic planning system, and a 6D-model-driven nuclear power plant construction support system are currently in progress

Major project team learning:examining building information modelling

The speed of technological advancement of software development drives the need for individual and team learning to exploit these developments for competitive advantage. Using a major long term redevelopment as a case study a review of learning processes and project team learning in the context of a voluntary approach to adopting of BIM prior to 2016 is examined. The speed of adoption of BIM across a large redevelopment project covering several years is variable and the differences of preparedness between team members from different organisations raises the question of how effective the project team can be in sharing learning and increasing the speed of adoption of BIM. The benefits of understanding the project environment as a formal learning context are recognised where teams are working in partnering arrangements but the focus is usually on post project review of what went wrong with little time to critically evaluate other variables. Knowledge Management has the potential to help understand and then facilitate greater participation amongst stakeholders in project team learning. The research team undertook decision mapping and knowledge elicitation techniques and applied these to the Dundee Waterfront to identify key factors relevant to successful project management, enabling the Waterfront Project Team to understand current practice. The effectiveness of project team learning in relation to BIM within this long-term major redevelopment is influenced by positive motivational drivers for individuals to learn how to use and apply BIM, the level of organisational support for learning and professional development and the project information and communication systems. In practice the current approach to sharing of knowledge within the project team indicates a fragmented approach in relation to the adoption and application of BIM to managing construction projects

Using VCL as an Aspect-Oriented Approach to Requirements Modelling

Software systems are becoming larger and more complex. By tackling the modularisation of crosscutting concerns, aspect-orientation draws attention to modularity as a means to address the problems of scalability, complexity and evolution in software systems development. Aspect-oriented modelling (AOM) applies aspect-orientation to the construction of models. Most existing AOM approaches are designed without a formal semantics, and use multi-view partial descriptions of behaviour. This paper presents an AOM approach based on the Visual Contract Language (VCL): a visual language for abstract and precise modelling, designed with a formal semantics, and comprising a novel approach to visual behavioural modelling based on design by contract where behavioural descriptions are total. By applying VCL to a large case study of a car-crash crisis management system, the paper demonstrates how modularity of VCL's constructs, at different levels of granularity, help to tackle complexity. In particular, it shows how VCL's package construct and its associated composition mechanisms are key in supporting separation of concerns, coarse-grained problem decomposition and aspect-orientation. The case study's modelling solution has a clear and well-defined modular structure; the backbone of this structure is a collection of packages encapsulating local solutions to concerns

Variability Abstractions: Trading Precision for Speed in Family-Based Analyses

Family-based (lifted) data-flow analysis for Software Product Lines (SPLs) is capable of analyzing all valid products (variants) without generating any of them explicitly. It takes as input only the common code base, which encodes all variants of a SPL, and produces analysis results corresponding to all variants. However, the computational cost of the lifted analysis still depends inherently on the number of variants (which is exponential in the number of features, in the worst case). For a large number of features, the lifted analysis may be too costly or even infeasible. In this paper, we introduce variability abstractions defined as Galois connections and use abstract interpretation as a formal method for the calculational-based derivation of approximate (abstracted) lifted analyses of SPL programs, which are sound by construction. Moreover, given an abstraction we define a syntactic transformation that translates any SPL program into an abstracted version of it, such that the analysis of the abstracted SPL coincides with the corresponding abstracted analysis of the original SPL. We implement the transformation in a tool, that works on Object-Oriented Java program families, and evaluate the practicality of this approach on three Java SPL benchmarks