No full-text available
To read the full-text of this research,
you can request a copy directly from the authors.
Towards Test-Driven Model Development in Production Systems Engineering
Abstract
The correct representation of discipline-specific and cross-specific knowledge in manufacturing contexts is becoming more important due to inter-disciplinary dependencies and overall higher system complexity. How- ever, domain experts do seldom have sufficient technical and theoretical knowledge or adequate tool support required for productive and effective model engineering and validation. Furthermore, increasing competi- tion and faster product lifecycle require the need for parallel collaborative engineering efforts from different workgroups. Thus, test-driven modeling, similar to test-driven software engineering can support the model engineering process to produce high-quality meta and instance models by incorporating consistency and se- mantic checks during the model engineering. We present a conceptual framework for model transformation with testing and debugging capabilities for production system engineering use cases supporting the mod- eling of discipline-specific AutomationML instance models. An exemplary workflow is presented and dis- cussed. Debug output for the models is generated to support non-technical engineers in the error detection of discipline-specific models. For future work user-friendly test definition is in planning.
... In addition, we built the entire system following test-oriented modeling. This approach incorporates consistency and semantics checks during system engineering and therefore helps to produce high-quality models [50]. Figure 3 represents the architecture of the open-source system we developed. ...
Despite efforts to define productivity, there is no consensus in the software industry regarding what the term productivity means and, instead of having only one metric or factor that describes productivity, it is defined by a set of aspects. Our objective is to develop a tool that supports the productivity measurement of software development teams according to the factors found in the literature. We divided these factors into four groups: People, Product, Organization, and Open Source Software Projects. We developed a web system containing the factors that influence productivity identified in this work, called Productive, to support software development teams in measuring their productivity. After developed the tool, we monitored its use over eight weeks with two small software development teams. From the results, we found that software development companies can use the system to support monitoring team productivity. The results also point to an improvement in productivity while using the system, and a survey applied to users demonstrates the users’ positive perception regarding the results obtained. In future work,
we will monitor the use of the tool and investigate the users’ perceptions in other project contexts.
... In [20] the authors propose a meta-modeling framework in engineering by examples to reduce errors and ensure consistency for designed models. In cooperation with a modeling expert, we designed a testing pipeline for validating and verifying AML instance models in a systematic way [31]. The advantage is that, fewer manual error detection and resolution has to be done after specifying constraints and test cases for the respective project configuration. ...
Technical Debt (TD) has proven to be a suitable communication concept for software-intensive contexts to raise awareness regarding longterm negative effects of deviations from standards and guidelines. TD has also been introduced to systems engineering domain, to communicate design shortcomings in long-running, software-assisted systems. We analysed potential TD in the engineering data exchange for production system engineering. Similar to requirements engineering in software-intensive systems, data exchange in the design phase plays an integral part in Software Engineering (SE) for Production Systems Engineering: Specifications, and physical logic have to be derived from heterogeneous plant models or parameter tables designed by different stakeholders. However, traditional procedures and inadequate tool support lead to inefficient data extraction and integration. We identified debt arising from knowledge representation, data model and the exchange process. The refinement validation of identified TD was achieved through semi-structured interviews with representatives in two analysed companies. In an online survey with ten participants from an industrial consortium we evaluated whether the identified TD concepts also applied to other companies, which is true for the majority of TD. Furthermore, we discuss promising TD management strategies to repay and manage negative effects and the accumulation of additional debt, such as improved communication, test-driven model engineering and visualisation of engineering models.
Domain experts typically have detailed knowledge of the concepts that are used in their domain; however they often lack the technical skills needed to translate that knowledge into Model-Driven Engineering (MDE) idioms and technologies. Flexible or bottom-up modelling has been introduced to assist with the involvement of domain experts by promoting the use of simple drawing tools. In traditional MDE the engineering process starts with the definition of a metamodel which is used for the instantiation of models. In bottom-up MDE example models are defined at the beginning, letting the domain experts and language engineers focus on expressing the concepts rather than spending time on technical details of the metamodelling infrastructure. The metamodel is then created manually or inferred automatically. The flexibility that bottom-up MDE offers comes with the cost of having nodes in the example models left untyped. As a result, concepts that might be important for the definition of the domain will be ignored while the example models cannot be adequately re-used in future iterations of the language definition process. In this paper, we propose a novel approach that assists in the inference of the types of untyped model elements using Constraint Programming. We evaluate the proposed approach in a number of example models to identify the performance of the prediction mechanism and the benefits it offers. The reduction in the effort needed to complete the missing types reaches up to 91.45% compared to the scenario where the language engineers had to identify and complete the types without guidance.
The term technical debt borrowed from financial debt describes the long-term negative effects of sub-optimal solutions to achieve short-term benefits. It has been widely studied so far in pure software systems. However, there is a lack of studies on technical debt in technical systems, which contain mechanical, electrical and software parts. Automated Production Systems are such technical systems. In this position paper, we introduce technical debt for Automated Production Systems and give examples from the different disciplines. Based on that description, we outline future research directions on technical debt in this field.
Test-driven development (TDD) is based on formalizing a piece of functionality as a test, implementing the functionality such that the test passes, and iterating the process. This paper describes a controlled experiment for evaluating an important aspect of TDD: in TDD, programmers write functional tests before the corresponding implementation code. The experiment was conducted with undergraduate students. While the experiment group applied a test-first strategy, the control group applied a more conventional development technique, writing tests after the implementation. Both groups followed an incremental process, adding new features one at a time and regression testing them. We found that test-first students on average wrote more tests and, in turn, students who wrote more tests tended to be more productive. We also observed that the minimum quality increased linearly with the number of programmer tests, independent of the development strategy employed.
To cope with the challenge of managing the complexity of automated production systems, model-based approaches are applied increasingly. However, due to the multitude of different disciplines involved in automated production systems engineering, e.g., mechanical, electrical, and software engineering, several modeling languages are used within a project to describe the system from different perspectives. To ensure that the resulting system models are not contradictory, the necessity to continuously diagnose and handle inconsistencies within and in between models arises. This article proposes a comprehensive approach that allows stakeholders to specify, diagnose, and handle inconsistencies in model-based systems engineering. In particular, to explicitly capture the dependencies and consistency rules that must hold between the disparate engineering models, a dedicated graphical modeling language is proposed. By means of this language, stakeholders can specify, diagnose, and handle inconsistencies in the accompanying inconsistency management framework. The approach is implemented based on the Eclipse Modeling Framework (EMF) and evaluated based on a demonstrator project as well as a small user experiment. First findings indicate that the approach is expressive enough to capture typical dependencies and consistency rules in the automated production system domain and that it requires less effort compared to manually developing inter-model inconsistency management solutions.
This book discusses how model-based approaches can improve the daily practice of software professionals. This is known as Model-Driven Software Engineering (MDSE) or, simply, Model-Driven Engineering (MDE). MDSE practices have proved to increase efficiency and effectiveness in software development, as demonstrated by various quantitative and qualitative studies. MDSE adoption in the software industry is foreseen to grow exponentially in the near future, e.g., due to the convergence of software development and business analysis. The aim of this book is to provide you with an agile and flexible tool to introduce you to the MDSE world, thus allowing you to quickly understand its basic principles and techniques and to choose the right set of MDSE instruments for your needs so that you can start to benefit from MDSE right away. The book is organized into two main parts. The first part discusses the foundations of MDSE in terms of basic concepts (i.e., models and transformations), driving principles, a...
Enterprise modeling (EM) methods and techniques are indispensable for understanding the present situation of an enterprise and for preparing for its future – particularly in times of continuous organizational change, an increasing pace of innovation, new market challenges or technology advances.
The authors combine a detailed description of the 4EM methodology with their concrete experience gathered in projects. Their book addresses the modeling procedure, modeling language and modeling practices in a uniquely integrated approach. It provides practical advice on common challenges faced by enterprises and offers a flexible EM method suitable for tackling those challenges. Much of the work presented stems from actual research projects and has been validated with scientific methods. The 4EM methodology has proven its practical value in a large number of successful development and/or change management projects in industry and the public sector.
The book was written for anyone who wants to learn more about EM, with a specific focus on how to do it in practice and/or how to teach it. Its main target audience thus includes instructors in the field of EM or business information systems, students in Information Systems or Business Administration, and practitioners working in enterprise or change management. The authors describe a clear reading path for each of these audiences and complement the work with a set of slides and further teaching material available on an accompanying website.
Test-Driven Development: A Practical Guide presents TDD from the perspective of the working programmer: real projects, real challenges, real solutions, ...real code. Dave Astels explains TDD through a start-to-finish project written in Java and using JUnit. He introduces powerful TDD tools and techniques; shows how to utilize refactoring, mock objects, and "programming by intention"; even introduces TDD frameworks for C++, C#/.NET, Python, VB6, Ruby, and Smalltalk. Invaluable for anyone who wants to write better code... and have more fun doing it!
Due to the complex system context of embedded-software applications, defects can cause life-threatening situations, delays can create huge costs, and insufficient productivity can impact entire economies. Providing better estimates, setting objectives, and identifying critical hot spots in embedded-software engineering requires adequate benchmarking data.
This contribution presents the basic architecture of the neutral data format AutomationML developed by the companies Daimler, ABB, Siemens, Rockwell, Kuka, Zuhlke, netAllied and the universities of Magdeburg and Karlsruhe. AutomationML serves for the data exchange between manufacturing engineering tools and therefore supports the interoperability between them. It covers information about the plant structure (topology and geometry) and the plant behaviour (logic and kinematics). The first version of AutomationML has been presented at the Hannover fair in 2008.
People managing production process need a new kind of decision support in the business environment which is being changed rapidly. They need new tools for dynamic modelling of enterprise processes to search for answers to the following basic questions: What is to be changed? To be changed into what? How to change it? This paper presents some new trends in the area of simulation of manufacturing systems and gives some recommendations, derived from experience, for effective simulation application in the whole production system life cycle. The paper summarises how discrete-event simulation can be used in the design, operation and continuous improvement of complex manufacturing and logistical systems. A combination of simulation with systems engineering methodology and the horizontal and vertical extension of simulation models in an enterprise are described. Last part of the paper briefly presents the main results of above-mentioned approach in logistics, flexible manufacturing, electrical engineering industry, furniture assembly and tyre manufacturing.
This paper discusses software development using the Test Driven Development (TDD) methodology in two different environments (Windows and MSN divisions) at Microsoft. In both these case studies we measure the various context, product and outcome measures to compare and evaluate the efficacy of TDD. We observed a significant increase in quality of the c ode (greater than two times) for projects developed using TDD compared to similar projects developed in the same organization in a no n-TDD fashion. The projects also took at least 15% extra upfront t ime for writing the tests. Additionally, the unit tests have served as auto documentation for the code when libraries/APIs had to be used as well as for code maintenance.
Test-driven development is a software development practice that has been used sporadically for decades. With this practice, test cases (preferably automated) are incrementally written before production code is implemented. Test-driven development has recently re-emerged as a critical enabling practice of the extreme programming software development methodology. We ran a case study of this practice at IBM. In the process, a thorough suite of automated test cases was produced after UML design. In this case study, we found that the code developed using a test-driven development practice showed, during functional verification and regression tests, approximately 40% fewer defects than a baseline prior product developed in a more traditional fashion. The productivity of the team was not impacted by the additional focus on producing automated test cases. This test suite aids in future enhancements and maintenance of this code. The case study and the results are discussed in detail.
A new software development process called test-driven modeling applies the Extreme Programming test-driven paradigm in a model-driven development environment. (The basis of this article is a project in Motorola's iDEN division that is extending and migrating a large legacy telecommunication system to new platforms using TDM.) This process involves automatic testing through simulation and using executable models as living software system architecture documents. In TDM, we use the same message sequence charts (MSCs) for both system analysis (or design documents) and unit test cases. Similarly, we use the same high-level modeling diagrams for both automatic code generation and living software architecture documents to guide the system's detailed implementation in later phases. Practical results show that developers can effectively apply TDM to large projects with high productivity and quality in terms of the number of code defects.
Technical Debt Analysis in Parallel Multi-Disciplinary Systems Engineering
- S Biffl
- F Ekaputra
- A Lüder
- J Pauly
- F Rinker
- L Waltersdorfer
- D Winkler
Biffl, S., Ekaputra, F., Lüder, A., Pauly, J., Rinker, F.,
Waltersdorfer, L., and Winkler, D. (2019a). Technical Debt Analysis in Parallel Multi-Disciplinary Systems Engineering. In 2019 45th Euromicro Conference on Software Engineering and Advanced Applications (SEAA), pages 342-346. IEEE.
Efficient engineering data exchange in multidisciplinary systems engineering
- S Biffl
- A Lüder
- F Rinker
- L Waltersdorfer
Biffl, S., Lüder, A., Rinker, F., and Waltersdorfer, L.
(2019b). Efficient engineering data exchange in multidisciplinary systems engineering. In International
Conference on Advanced Information Systems Engineering, pages 17-31. Springer.
Example-driven metamodel development
- J J López-Fernández
- J S Cuadrado
- E Guerra
- De Lara
López-Fernández, J. J., Cuadrado, J. S., Guerra, E.,
and De Lara, J. (2015). Example-driven metamodel development. Software & Systems Modeling,
14(4):1323-1347.
VDI Richtlinie 3695: Engineering von Anlagen-Evaluieren und Optimieren des Engineerings
- Verein Deutscher Ingenieure
Verein Deutscher Ingenieure (2009). VDI Richtlinie 3695:
Engineering von Anlagen-Evaluieren und Optimieren
des Engineerings. VDI-Verlag, Düsseldorf.