|RNDr. Viliam Šimko, Ph.D.|
Tel: +49 721/608-41885
Chair Prof. Reussner
Personal Homepage: http://vlx.matfyz.cz
- Data Mining, Statistical Classification
- Application of Natural Language Processing in the area of Software Engineering
- Lightweight Formal Methods
- Component-based software engineering
- Meta-modeling (mainly UML, EMF, OWL)
- Archiving and long-term preservation
- Concurrency and synchronization
Jiri Vinarek, Petr Hnetynka, Viliam Simko, and Petr Kroha.
Recovering traceability links between code and specification through
domain model extraction.
In Proceedings of 10th International Workshop, EOMAS 2014, Held
at CAiSE 2014, Thessaloniki, Greece, June 16-17, 2014, volume 191 of
[ bib |
Requirements traceability is an extremely important aspect of software development and especially of maintenance. Efficient maintaining of traceability links between high-level requirements specification and low-level implementation is hindered by many problems. In this paper, we propose a method for automated recovery of links between parts of the textual requirement specification and the source code of implementation. The described method is based on a method allowing extraction of a prototype domain model from plain text requirements specification. The proposed method is evaluated on two non-trivial examples. The performed experiments show that our method is able to link requirements with source code with the accuracy of F1=58-61%.
Ivan Dario Paez Anaya, Viliam Simko, Johann Bourcier, and Noel Plouzeau.
A prediction-driven adaptation approach for self-adaptive sensor
In Proceedings of 9th International Symposium on Software
Engineering for Adaptive and Self-Managing Systems (SEAMS'14), Hyderabad,
India, May 31, 2014.
[ bib |
Engineering self-adaptive software in unpredictable environments such as pervasive systems, where network's ability, remaining battery power and environmental conditions may vary over the lifetime of the system is a very challenging task. Many current software engineering approaches leverage run-time architectural models to ease the design of the autonomic control loop of these self-adaptive systems. While these approaches perform well in reacting to various evolutions of the runtime environment, implementations based on reactive paradigms have a limited ability to anticipate problems, leading to transient unavailability of the system, useless costly adaptations, or resources waste. In this paper, we follow a proactive self-adaptation approach that aims at overcoming the limitation of reactive approaches. Based on predictive analysis of internal and external context information, our approach regulates new architecture reconfigurations and deploys them using models at runtime. We have evaluated our approach on a case study where we combined hourly temperature readings provided by National Climatic Data Center (NCDC) with fire reports from Moderate Resolution Imaging Spectroradiometer (MODIS) and simulated the behavior of multiple systems. The results confirm that our proactive approach outperforms a typical reactive system in scenarios with seasonal behavior.
Viliam Simko, David Hauzar, Petr Hnetynka, Tomas Bures, and Frantisek Plasil.
Formal verification of annotated textual use-cases.
The Computer Journal, 2014.
accepted for publication.
[ bib |
Textual use-cases have been traditionally used in the initial stages of the software development process to describe software functionality from the user's perspective. Their advantage is that they can be easily understood by stakeholders and domain experts. However, since use-cases typically rely on natural language, they cannot be directly subject to a formal verification. In this article, we present a method (called FOAM) for formal verification of use-cases. This method features simple user-definable annotations, which are inserted into a use-case to make its semantics more suitable for verification. Subsequently a model-checking tool is employed to verify temporal invariants associated with the annotations. This way, FOAM allows harnessing the benefits of model-checking while still keeping the use-cases understandable for non-experts.
Viliam Simko, Petr Hnetynka, Tomas Bures, and Frantisek Plasil.
FOAM : A Lightweight Method for Verification of Use-Cases.
In Proceedings of the 38th Euromicro Conference on Software
Engineering and Advanced Applications (SEAA), Cesme, Izmir, Turkey,
September 5-8, 2012, pages 228-232. IEEE/ACM.
[ bib |
The advantage of textual use-cases is that they can be easily understood by stakeholders and domain experts. However, since use-cases typically rely on a natural language, they cannot be directly subject to a formal verification. In this paper, we present Formal Verification of Annotated Use-Case Models (FOAM) method which features simple user-definable annotations, inserted into a use-case to make its semantics more suitable for verification. Subsequently a model-checking tool verifies temporal invariants associated with the annotations. This way, FOAM allows for harnessing the benefits of model-checking while still keeping the use-cases understandable for non-experts.
Viliam Simko, David Hauzar, Petr Hnetynka, and Frantisek Plasil.
Verifying temporal properties of use-cases in natural language.
In Postproceedings of 8th International Symposium on Formal
Aspects of Component Software (FACS'11) conference, Oslo, Norway, September
14-16, 2011, LNCS. Springer.
[ bib |
This paper presents a semi-automated method that helps iteratively write use-cases in natural language and verify consistency of behavior encoded within them. In particular, this is beneficial when the use-cases are created simultaneously by multiple developers. The proposed method allows verifying the consistency of textual use-case specification by employing annotations in use-case steps that are transformed into temporal logic formulae and verified within a formal behavior model. A supporting tool for plain English use-case analysis is currently being enhanced by integrating the verification algorithm proposed in the paper.
Viliam Simko, Petr Hnerynka, and Tomas Bures.
From textual use-cases to component-based applications.
In Software Engineering, Artificial Intelligence, Networking and
Parallel/Distributed Computing 2010, Roger Lee, Jixin Ma, Liz Bacon, Wencai
Du, and Miltos Petridis, editors, 2010, Studies in Computational
Intelligence, pages 23-37. Springer Berlin Heidelberg.
[ bib |
A common practice to capture functional requirements of a software system is to utilize use-cases, which are textual descriptions of system usage scenarios written in a natural language. Since the substantial information about the system is captured by the use-cases, it comes as a natural idea to generate from these descriptions the implementation of the system (at least partially). However, the fact that the use-cases are in a natural language makes this task extremely difficult. In this paper, we describe a model-driven tool allowing code of a system to be generated from use-cases in plain English. The tool is based on the model-driven development paradigm, which makes it modular and extensible, so as to allow for use-cases in multiple language styles and generation for different component frameworks.