325 research outputs found
The Role of Computers in Research and Development at Langley Research Center
This document is a compilation of presentations given at a workshop on the role cf computers in research and development at the Langley Research Center. The objectives of the workshop were to inform the Langley Research Center community of the current software systems and software practices in use at Langley. The workshop was organized in 10 sessions: Software Engineering; Software Engineering Standards, methods, and CASE tools; Solutions of Equations; Automatic Differentiation; Mosaic and the World Wide Web; Graphics and Image Processing; System Design Integration; CAE Tools; Languages; and Advanced Topics
Verification of Branching-Time and Alternating-Time Properties for Exogenous Coordination Models
Information and communication systems enter an increasing number of areas of daily lives. Our reliance and dependence on the functioning of such systems is rapidly growing together with the costs and the impact of system failures. At the same time the complexity of hardware and software systems extends to new limits as modern hardware architectures become more and more parallel, dynamic and heterogenous. These trends demand for a closer integration of formal methods and system engineering to show the correctness of complex systems within the design phase of large projects.
The goal of this thesis is to introduce a formal holistic approach for modeling, analysis and synthesis of parallel systems that potentially addresses complex system behavior at any layer of the hardware/software stack. Due to the complexity of modern hardware and software systems, we aim to have a hierarchical modeling framework that allows to specify the behavior of a parallel system at various levels of abstraction and that facilitates designing complex systems in an iterative refinement procedure, in which more detailed behavior is added successively to the system description. In this context, the major challenge is to provide modeling formalisms that are expressive enough to address all of the above issues and are at the same time amenable to the application of formal methods for proving that the system behavior conforms to its specification. In particular, we are interested in specification formalisms that allow to apply formal verification techniques such that the underlying model checking problems are still decidable within reasonable time and space bounds.
The presented work relies on an exogenous modeling approach that allows a clear separation of coordination and computation and provides an operational semantic model where formal methods such as model checking are well suited and applicable. The channel-based exogenous coordination language Reo is used as modeling formalism as it supports hierarchical modeling in an iterative top-down refinement procedure. It facilitates reusability, exchangeability, and heterogeneity of components and forms the basis to apply formal verification methods. At the same time Reo has a clear formal semantics based on automata, which serve as foundation to apply formal methods such as model checking.
In this thesis new modeling languages are presented that allow specifying complex systems in terms of Reo and automata models which yield the basis for a holistic approach on modeling, verification and synthesis of parallel systems. The second main contribution of this thesis are tailored branching-time and alternating time temporal logics as well as corresponding model checking algorithms. The thesis includes results on the theoretical complexity of the underlying model checking problems as well as practical results. For the latter the presented approach has been implemented in the symbolic verification tool set Vereofy. The implementation within Vereofy and evaluation of the branching-time and alternating-time model checker is the third main contribution of this thesis
Modelling for data management & exchange in Concurrent Engineering - A case study of civil aircraft assembly line
This research aims to improve the dataflow performance of the Concurrent
Engineering (CE) practice in the detail design stage of the aircraft Assembly
Line (AL) in the C919 aircraft project. As the final integrator of the aircraft,
Shanghai Aircraft Manufacturing Company Ltd. (SAMC) is responsible for
developing the AL with global suppliers. Although CE has been implemented in
AL projects to shorten lead time, reduce development cost and improve design
quality, the lack of experience and insufficient infrastructure may lead to many
challenges in cooperation with distributed suppliers, especially regarding data
management/exchange and workflow control. In this research, the particular CE
environment and activities in SAMC AL projects were investigated. By
assessing the CE performance and benchmarking, the improvement
opportunities are identified, and then an activity-oriented workflow and dataflow
model is established by decomposing the work process to detail levels. Based
on this model, a Product Data Management (PDM) based support platform is
proposed to facilitate data management/exchange in dynamic workflow to
improve work efficiency and interoperability. This solution is mocked-up on the
Siemens Teamcenter 8.1 PLM(Product Lifecycle Management) software and its
feasibility is checked. The mock-up is evaluated by SAMC experts and suppliers.
The feedback shows the acceptance of the model by experts and the urgency
of improving data/work flow design before PLM implementing.
The result of this research is useful for enterprises in similar environments
transiting from pre-PLM to implementing PLM and who wanting to strengthen
CE in the new product development
Recommended from our members
Formalizing graphical notations
The thesis describes research into graphical notations for software engineering, with a principal interest in ways of formalizing them. The research seeks to provide a theoretical basis that will help in designing both notations and the software tools that process them.
The work starts from a survey of literature on notation, followed by a review of techniques for formal description and for computational handling of notations. The survey concentrates on collecting views of the benefits and the problems attending notation use in software development; the review covers picture description languages, grammars and tools such as generic editors and visual programming environments. The main problem of notation is found to be a lack of any coherent, rigorous description methods. The current approaches to this problem are analysed as lacking in consensus on syntax specification and also lacking a clear focus on a defined concept of notated expression.
To address these deficiencies, the thesis embarks upon an exploration of serniotic, linguistic and logical theory; this culminates in a proposed formalization of serniosis in notations, using categorial model theory as a mathematical foundation. An argument about the structure of sign systems leads to an analysis of notation into a layered system of tractable theories, spanning the gap between expressive pictorial medium and subject domain. This notion of 'tectonic' theory aims to treat both diagrams and formulae together.
The research gives details of how syntactic structure can be sketched in a mathematical sense, with examples applying to software development diagrams, offering a new solution to the problem of notation specification. Based on these methods, the thesis discusses directions for resolving the harder problems of supporting notation design, processing and computer-aided generic editing. A number of future research areas are thereby opened up. For practical trial of the ideas, the work proceeds to the development and partial implementation of a system to aid the design of notations and editors. Finally the thesis is evaluated as a contribution to theory in an area which has not attracted a standard approach
A Systematic Study of Design Conflict: Modeling, Representation, Resolution, and Application
ABSTRACT
A Systematic Study of Design Conflict: Modeling, Representation, Resolution, and Application
Baiquan Yan, Ph.D.
Concordia University, 2013
Conflicts drive the development of technical systems and the evolution of design process. Conflict management, which mainly includes conflict identification and resolution, is a crucial part of design activity. This research conducts a systematic study and proposes a formal structure of design conflicts.
The first step of conflict management is to build up a formal model for technical system. Currently, there exist some inconsistences among different design theories because of the lack of a cohesive set of fundamental concepts about technical systems. This lack also causes misunderstanding among researchers and therefore hinders the development of design theories. This thesis presents a formal approach to representing technical systems. Both theoretical derivation and extensive example have shown that this formal representation meets the five requirements: completeness, clarity, independence, flexibility, and adaptability. A set five concepts— purpose, function, structure, behaviour and state— is identified and formally defined as the base set for technical systems.
The second step is to model conflicts based on the formalization of technical system. Current studies are based on heuristics and lack a systematic approach, and therefore fail to detect conflicts that are not predefined. This research puts forward a formal structure of design conflicts based on systematic analysis. This formal structure shows that any conflict is composed of at least three objects: two competing objects and one resource object that the former two contend for. This formal structure can be applied to different design fields and helps designers identify all conflicts existed in different design stages.
Based on the formal structure of conflicts and analysis of relation among the three objects in a conflict, this research also proposes three formal methods for detecting conflicts and presents a set of general resolution principles, which include modifying resource object, separating conflict relations in time or in space, changing the two competing objects, using optimization methods, and replacing the whole conflict.
An example demonstrates the application of the formal structures, followed with conclusion and suggestions for future research
A Business User Model-Driven Engineering Method for Developing Information Systems
This thesis is all about raising the level of abstraction at which information systems are built, using business end-users knowledge and MDE to achieve the result. The work intro- duces, first, Micro-Modelling Language (μML), a lightweight modelling language that is used to express basic structural and behavioural aspects of information systems using effectivily business-users knowledge of their desired system. Throughout the work, graphical notation and semantics for the language concepts are identified, providing a simpler and semantically cleaned modelling language than standard UML and other UML-based languages.
The work also proposes BUILD (Business-User Information-Led Development), an End- User MDE approach to support the construction of information systems using high-level specifications and accelerate the development process using layered model transformation and code generation. Throughout the thesis, a number of development phases and model transformation steps are identified to allow the low-level technical detail be introduced and developed automatically by rules, with less end-users engagement. Domain-Specific code generators, for generating executable Java Swing Applications code and MySQL script, are used to demonstrate the validity of the research
Creating and Maintaining Consistent Documents with Elucidative Development
Software systems usually consist of multiple artefacts, such as requirements, class diagrams, or source code. Documents, such as specifications and documentation, can also be viewed as artefacts. In practice, however, writing and updating documents is often neglected because it is expensive and brings no immediate benefit. Consequently, documents are often outdated and communicate wrong information about the software. The price is paid later when a software system must be maintained and much implicit knowledge that existed at the time of the original development has been lost.
A simple way to keep documents up to date is generation. However, not all documents can be fully generated. Usually, at least some content must be written by a human author. This handwritten content is lost if the documents must be regenerated.
In this thesis, Elucidative Development is introduced. It is an approach to create documents by partial generation. Partial generation means that some parts of the document are generated whereas others are handwritten. Elucidative Development retains manually written content when the document is regenerated. An integral part of Elucidative Development is a guidance system, which informs the author about changes in the generated content and helps him update the handwritten content.:1 Introduction
1.1 Contributions
1.2 Scope of the Thesis
1.3 Organisation
2 Problem Analysis and Solution Outline
2.1 Redundancy and Inconsistency
2.2 Improving Consistency with Partial Generation
2.3 Conclusion
3 Background
3.1 Grammar-Based Modularisation
3.2 Model-Driven Software Development
3.3 Round-Trip Engineering
3.4 Conclusion
4 Elucidative Development
4.1 General Idea and Running Example
4.2 Requirements of Elucidative Development
4.3 Structure and Basic Concepts of Elucidative Documents
4.4 Presentation Layer
4.5 Guidance
4.6 Conclusion
5 Model-Driven Elucidative Development
5.1 General Idea and Running Example
5.2 Requirements of Model-Driven Elucidative Development
5.3 Structure and Basic Concepts of Elucidative Documents in Model-Driven Elucidative Development
5.4 Guidance
5.5 Conclusion
6 Extensions of Elucidative Development
6.1 Validating XML-based Elucidative Documents
6.2 Backpropagation-Based Round-Trip Engineering for Computed Text Document Fragments
6.3 Conclusion
7 Tool Support for an Elucidative Development Environment
7.1 Managing Active References
7.2 Inserting Computed Document Fragments
7.3 Caching the Computed Document Fragments
7.4 Elucidative Document Validation with Schemas
7.5 Conclusion
8 Related Work
8.1 Related Documentation Approaches
8.2 Consistency Approaches
8.3 Compound Documents
8.4 Conclusion
9 Evaluation
9.1 Creating and Maintaining the Cool Component Specification
9.2 Creating and Maintaining the UML Specification
9.3 Feasibility Studies
9.4 Conclusion
10 ConclusionSoftwaresysteme setzen sich üblicherweise aus vielen verschiedenen Artefakten zusammen, zum Beispiel Anforderungen, Klassendiagrammen oder Quellcode. Dokumente, wie zum Beispiel Spezifikationen oder Dokumentation, können auch als Artefakte betrachtet werden. In der Praxis wird aber das Schreiben und Aktualisieren von Dokumenten oft vernachlässigt, weil es zum einen teuer ist und zum anderen keinen unmittelbaren Vorteil bringt. Dokumente sind darum häufig veraltet und vermitteln falsche Informationen über die Software. Den Preis muss man später zahlen, wenn die Software gepflegt wird, weil viel von dem impliziten Wissen, das zur Zeit der Entwicklung existierte, verloren ist.
Eine einfache Möglichkeit, Dokumente aktuell zu halten, ist Generierung. Allerdings können nicht alle Dokumente generiert werden. Meist muss wenigstens ein Teil von einem Menschen geschrieben werden. Dieser handgeschriebene Inhalt geht verloren, wenn das Dokument neu generiert werden muss.
In dieser Arbeit wird das Elucidative Development vorgestellt. Dabei handelt es sich um einen Ansatz zur Dokumenterzeugung mittels partieller Generierung. Das bedeutet, dass Teile eines Dokuments generiert werden und der Rest von Hand ergänzt wird. Beim Elucidative Development bleibt der handgeschriebene Inhalt bestehen, wenn das restliche Dokument neu generiert wird. Ein integraler Bestandteil von Elucidative Development ist darüber hinaus ein Hilfesystem, das den Autor über Änderungen an generiertem Inhalt informiert und ihm hilft, den handgeschriebenen Inhalt zu aktualisieren.:1 Introduction
1.1 Contributions
1.2 Scope of the Thesis
1.3 Organisation
2 Problem Analysis and Solution Outline
2.1 Redundancy and Inconsistency
2.2 Improving Consistency with Partial Generation
2.3 Conclusion
3 Background
3.1 Grammar-Based Modularisation
3.2 Model-Driven Software Development
3.3 Round-Trip Engineering
3.4 Conclusion
4 Elucidative Development
4.1 General Idea and Running Example
4.2 Requirements of Elucidative Development
4.3 Structure and Basic Concepts of Elucidative Documents
4.4 Presentation Layer
4.5 Guidance
4.6 Conclusion
5 Model-Driven Elucidative Development
5.1 General Idea and Running Example
5.2 Requirements of Model-Driven Elucidative Development
5.3 Structure and Basic Concepts of Elucidative Documents in Model-Driven Elucidative Development
5.4 Guidance
5.5 Conclusion
6 Extensions of Elucidative Development
6.1 Validating XML-based Elucidative Documents
6.2 Backpropagation-Based Round-Trip Engineering for Computed Text Document Fragments
6.3 Conclusion
7 Tool Support for an Elucidative Development Environment
7.1 Managing Active References
7.2 Inserting Computed Document Fragments
7.3 Caching the Computed Document Fragments
7.4 Elucidative Document Validation with Schemas
7.5 Conclusion
8 Related Work
8.1 Related Documentation Approaches
8.2 Consistency Approaches
8.3 Compound Documents
8.4 Conclusion
9 Evaluation
9.1 Creating and Maintaining the Cool Component Specification
9.2 Creating and Maintaining the UML Specification
9.3 Feasibility Studies
9.4 Conclusion
10 Conclusio
Formal Methods Specification and Analysis Guidebook for the Verification of Software and Computer Systems
This guidebook, the second of a two-volume series, is intended to facilitate the transfer of formal methods to the avionics and aerospace community. The 1st volume concentrates on administrative and planning issues [NASA-95a], and the second volume focuses on the technical issues involved in applying formal methods to avionics and aerospace software systems. Hereafter, the term "guidebook" refers exclusively to the second volume of the series. The title of this second volume, A Practitioner's Companion, conveys its intent. The guidebook is written primarily for the nonexpert and requires little or no prior experience with formal methods techniques and tools. However, it does attempt to distill some of the more subtle ingredients in the productive application of formal methods. To the extent that it succeeds, those conversant with formal methods will also nd the guidebook useful. The discussion is illustrated through the development of a realistic example, relevant fragments of which appear in each chapter. The guidebook focuses primarily on the use of formal methods for analysis of requirements and high-level design, the stages at which formal methods have been most productively applied. Although much of the discussion applies to low-level design and implementation, the guidebook does not discuss issues involved in the later life cycle application of formal methods
- …