Search

Robots have become collaborators in our daily life. While robotic systems become more and more complex, the need to engineer their software development grows as well. The traditional approaches used in developing these software systems are reaching their limits; currently used methodologies and tools fall short of addressing the needs of such complex software development. Separating robotics’ knowledge from short-cycled implementation technologies is essential to foster reuse and maintenance. This paper presents a systematic review (SLR) of the current use of modern software engineering techniques for developing robotic software systems and their actual automation level. The survey was aimed at summarizing existing evidence concerning applying such technologies to the field of robotic systems to identify any gaps in current research to suggest areas for further investigation and provide a background for positioning new research activities.

The need for high-performance computing together with the increasing trend from single processor to parallel computer architectures has leveraged the adoption of parallel computing. To benefit from parallel computing power, usually parallel algorithms are defined that can be mapped and executed on parallel computing platforms. In general, different alternative mappings can be defined each with different performance. For small computing platforms with a limited number of processing nodes, the mapping process can be carried out manually. However, for large-scale parallel computing platforms in which hundreds of thousands of processing nodes are applied, the number of possible mapping alternatives increases dramatically, and the mapping process becomes intractable for the human engineer. To assist the parallel computing engineer, we provide a systematic approach to derive feasible mapping alternatives of parallel algorithms to parallel computing platforms. The approach includes activities for modeling the parallel algorithm and parallel computing platform, generation of feasible mapping alternatives, generation of the deployment code, and finally the deployment of the generated code to the nodes. We evaluate our approach for deriving feasible mapping alternatives for four well-known parallel algorithms. The evaluation is based on both simulations and real executions of the generated mapping alternatives. Copyright © 2016 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

TextX is a meta-language and a tool for building Domain-Specific Languages in Python. It’s built on top of the Arpeggio PEG parser and takes away the burden of converting parse trees to abstract representations from language designers. From a single grammar description, textX constructs Arpeggio parser and a meta-model in run-time. The meta-model contains all the information about the language and a set of Python classes inferred from grammar rules. The parser will parse programs/models written in the new language and construct Python object graph a.k.a. the model conforming to the meta-model. The textX tool has support for error reporting, debugging, and meta-model and model visualization. It is used in industrial environments and teaching Domain-Specific Languages course at the Faculty of Technical Sciences in Novi Sad. It is a free and open-source software available at GitHub under the MIT license. [ABSTRACT FROM AUTHOR]

Fragmentation of information across instances of different metamodels poses a significant problem for software developers and leads to a major increase in effort of transformation development. Moreover, compositions of metamodels tend to be incomplete, imprecise, and erroneous, making it impossible to present it to users or use it directly as input for applications. Customized views satisfy information needs by focusing on a particular concern, and filtering out information that is not relevant to this concern. For a broad establishment of view-based approaches, an automated solution to deal with separate metamodels and the high complexity of model transformations is necessary. In this paper, we present the ModelJoin approach for the rapid creation of views. Using a human-readable textual DSL, developers can define custom views declaratively without having to write model transformations or define a bridging metamodel. Instead, a metamodel generator and higher-order transformations create annotated target metamodels and the appropriate transformations on-the-fly. The resulting views, which are based on these metamodels, contain joined instances and can effectively express concerns unforseen during metamodel design. We have applied the ModelJoin approach and validated the textual DSL in a case study using the Palladio Component Model. [ABSTRACT FROM AUTHOR]

Software engineering plays a key role in state-of-the-art robotics where more effective and efficient software development solutions are needed for implementation and integration of advanced robotics capabilities. Component-based software engineering and model-driven software development are two paradigms suitable to deal with such challenges. This paper presents the analysis, design, and implementation of control software for an Autonomous Underwater Vehicle (AUV). The software development stages are carried out by using a model-driven toolchain that provides support to design and build component-based software for robotics applications. A case study of a high-performance AUV control application and experimental results from a software schedulability analysis are presented. [ABSTRACT FROM AUTHOR]

Model-driven software development is surrounded by numerous myths and misunderstandings that hamper its adoption. For long, our students were victims of these myths and considered MDSD impractical and only applied in academy. In this paper we discuss these myths and present our experience with devising an MDSD course that challenges them and motivates students to understand MDSD principles. The main contribution of this work is a set of MDSD teaching guidelines that can make the course pragmatic in the eyes of students - programmers. These guidelines introduce MDSD from the viewpoint of a programmer as a pragmatic tool for solving concrete problems in the development process. In our MDSD course we implemented the presented guidelines. The course shows several techniques and principles of model-driven development in multiple incremental iterations instead of concentrating on a single tool. At the same time we unite these techniques by using a dynamic visualisation tool that shows to the students the whole infrastructure in the big picture. The course is implemented as an iterative incremental MDSD case study. The paper concludes with a survey performed with our students that indicates positive results of the approach. [ABSTRACT FROM AUTHOR]

Robotic systems are complex, software intensive and heterogeneous composite systems. Software systems engineering and system integration is still a major challenge in robotics. We describe how component based software engineering (CBSE), model-driven software development (MDSD) and domain-specific languages (DSLs) for variability management complement each other in addressing the robotics software challenge. We outline how these approaches pave the way towards a software business ecosystem in robotics. We put a focus onto challenges still being considered as open and worth being addressed next. [ABSTRACT FROM AUTHOR]

Syntax-directed translation tools require the specification of a language by means of a formal grammar. This grammar must also conform to the specific requirements of the parser generator to be used. Software engineers then annotate the resulting grammar with semantic actions for the resulting system to perform its desired functionality. Whenever the input text format is modified, the grammar has to be updated and the subsequent changes propagate throughout the entire language processing tool chain. Moreover, if several applications use the same language, multiple copies of the same language specification have to be maintained in sync, since language specification (i.e. the grammar) is tightly coupled to language processing (i.e. the semantic actions that annotate that grammar). In this paper, we introduce ModelCC, a model-based parser generator that decouples language specification from language processing, hence avoiding the aforementioned problems that are caused by grammar-driven parser generators. ModelCC receives a conceptual model as input, along with constraints that annotate it. It is then able to create a parser for a given textual representation format, so that the generated parser fully automates the instantiation of the desired conceptual model. ModelCC is also a powerful tool for the design of domain-specific languages. [ABSTRACT FROM AUTHOR]

Model-driven software modernization is a discipline in which model-driven development (MDD) techniques are used in the modernization of legacy systems. When existing software artifacts are evolved, they must be transformed into models to apply MDD techniques such as model transformations. Since most modernization scenarios (e.g., application migration) involve dealing with code in general-purpose programming languages (GPL), the extraction of models from GPL code is an essential task in a model-based modernization process. This activity could be performed by tools to bridge grammarware and MDD technical spaces, which is normally carried out by dedicated parsers. Grammar-to-Model Transformation Language (Gra2MoL) is a domain-specific language (DSL) tailored to the extraction of models from GPL code. This DSL is actually a text-to-model transformation language which can be applied to any code conforming to a grammar. Gra2MoL aims to reduce the effort needed to implement grammarware-MDD bridges, since building dedicated parsers is a complex and time-consuming task. Like ATL and RubyTL languages, Gra2MoL incorporates the binding concept needed to write mappings between grammar elements and metamodel elements in a simple declarative style. The language also provides a powerful query language which eases the retrieval of scattered information in syntax trees. Moreover, it incorporates extensibility and grammar reuse mechanisms. This paper describes Gra2MoL in detail and includes a case study based on the application of the language in the extraction of models from Delphi code. [ABSTRACT FROM AUTHOR]

The Institutional Repositories (IR) have been consolidated into the academy, the proof of this is the growth in number of records in existing directories made by various means, such as self-archiving by authors and the incorporation of material by librarians. In this paper, a bibliographic survey about the use of the Model-Driven Software Development approach is done (MDD) in the IR systems in order to establish a relationship between them. The MDD is a paradigm for building software that assigns a central role to the models and originates models that range from the most abstract to the most concrete. This paradigm also provides a framework that allows the interested ones to share their points of view and directly manipulate the representations of the domain entities from IR. In conclusion, the monitoring of the various researches, and what is expressed here, allow to encourage the implementation of software for IR. [ABSTRACT FROM AUTHOR]

Support for separation of roles is decisive towards a successful business ecosystem where various stakeholders with dedicated expertises network and collaborate. However, it depends on means for composition(system of systems, reuse of black boxes). This paper proposes Dynamic State Charts as an extension of state charts for composition and coordination of complex robot behavior which is one of the challenges in service robotics. Their states allow to refine their content by choosing from a set of alternative matching state instances for robust task execution and to manage the complexity of real-world tasks. Dynamic State Charts allow reuse and can be bundled with software components and are provided in a repository (idea of an 'robot app store') as a step towards composition and separation of roles as necessary for a business ecosystem in service robotics. The approach is demonstrated in a practical application with a service robot. [ABSTRACT FROM AUTHOR]

This paper presents some of the model-driven Web engineering methods that have been proposed, and discusses and analyzes the advantages and disadvantages of such methods regarding current tendencies and best practices on model-driven engineering. The idea is to present each approach and analyze the models they propose to represent Web applications, the architectural aspects in the transformations, and the use of current Web user interface technologies in the generated code. This is done in order to depict possible research lines for future works on the model-driven Web engineering area.

Copyright of Automatisierungstechnik is the property of De Gruyter and its content may not be copied or emailed to multiple sites or posted to a listserv without the copyright holder's express written permission. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.)

Creation of an unambiguous requirements specification with precise domain vocabulary is crucial for capturing the essence of any software system, either when developing a new system or when recovering knowledge from a legacy one. Software specifications usually maintain noun notions and include them in central vocabularies. Verb or adjective phrases are easily forgotten and their definitions buried inside imprecise paragraphs of text. This paper proposes a model-based language for comprehensive treatment of domain knowledge, expressed through constrained natural language phrases that are grouped by nouns and include verbs, adjectives and prepositions. In this language, vocabularies can be formulated to describe behavioural characteristics of a given problem domain. What is important, these characteristics can be linked from within other specifications similarly to a wiki. The application logic can be formulated through sequences of imperative subject-predicate sentences containing only links to the phrases in the vocabulary. The paper presents an advanced tooling framework to capture application logic specifications making them available for automated transformations down to code. The tools were validated through a controlled experiment. [ABSTRACT FROM AUTHOR]

Process modeling has become an established technique to document, analyse and automate workflows. Workflows that model the procedures followed by professionals require the immediate contribution of these professionals, who usually lack broad knowledge of formal models as well as software engineering skills. Simplicity of the selected modeling approach throughout each step of the design phase is therefore a key factor for the success of a workflow management project. In this paper we show a process modelling framework that combines simplicity and intuitiveness in the modeling phase with immediate evaluation of the models via execution. This combination allows practitioners and professionals to play a key role in the rapid development of IT applications and systems that support role-based workflows. We discuss the practicability and benefits of this approach on an exemplary case study from the healthcare domain: analysis and optimization of outpatient clinic processes of a leading German hospital. [ABSTRACT FROM AUTHOR]

Abstract: This paper describes a CASE tool for developing complex systems in which heterogeneous and autonomous agents may need to coexist in a complex social and legal framework. Model-Driven Technologies are used to integrate the design of systems of this kind with the verification of the models and with the generation of executable code from these models. The verification module is based on model-checking techniques to check the coherence of a modeled legal context at design time is presented and it is exemplified with a case study. [Copyright &y& Elsevier]

Abstract: Over the last two decades, Collaborative Systems have become increasingly popular thanks to the many advances made in networks, communications and software tools. Within this field, Collaborative Modeling Systems apply the collaborative paradigm to the construction of (often visual) models, where users build diagrams from building blocks and the relationships between them. In these kinds of applications, the work is usually arranged into sessions, with the definition of some kind of time organization between those sessions. This organization is known as a collaboration protocol. Unfortunately, it is not usually easy to define these protocols, and many applications do not allow users to make any use of them. In an effort to overcome these difficulties, in this paper we propose a visual language for defining collaboration protocols for these systems. As such, in our language, sessions, artifacts and the transformations between them can be specified visually, and different coordination relationships (such as fork and join) can be defined. The visual language is included in a development method for collaborative systems that take advantage of the Eclipse platform in order to develop model-driven graphical editors that are enhanced with collaboration capabilities. [Copyright &y& Elsevier]

This paper proposes model-driven techniques to extend IBM's SOMA method towards migrating legacy systems into Service-Oriented Architectures (SOA). The proposal explores how graph-based querying and transformation techniques enable the integration of legacy assets into a new SOA and how these techniques can be integrated into the overall migration process. The presented approach is applied to the identification and migration of services in an open source Java software system. [ABSTRACT FROM AUTHOR]

A steel thread is a software engineering construct that identifies the most important execution paths, including software and hardware elements, through a computer system, while meeting business objectives and demonstrating executable architecture. Steel threads are often used in the context of defining software system architecture. Although there have been references to steel threads in software engineering literature, it is hard to find clear definitions and usage of steel threads in the software industry or among the research community. This paper provides an overview of steel threads in software architecture design and development as well as presenting the contexts of steel threads. In addition, we show how to identify important scenarios and execution paths to construct steel threads and discuss the contexts under which steel threads are applicable in the software development life cycle. We also discuss the roles of steel threads in system development as well as their usability and applicability. Finally, a case study of the use of steel threads in a software system is presented. [ABSTRACT FROM AUTHOR]

Copyright of Revista Facultad de Ingeniería Universidad de Antioquia is the property of Universidad de Antioquia and its content may not be copied or emailed to multiple sites or posted to a listserv without the copyright holder's express written permission. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.)

Copyright of Revista Ingeniería e Investigación is the property of Universidad Nacional de Colombia, Facultad de Ingenieraia and its content may not be copied or emailed to multiple sites or posted to a listserv without the copyright holder's express written permission. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.)

Model-driven software development (MDSD) aims to support the development and evolution of software intensive systems using the basic concepts of model, metamodel, and model transformation. In parallel with the ongoing academic research, MDSD is more and more applied in industrial practices. After being accepted both by a broad community of researchers and the industry, it is now being introduced in university courses. This article describes the experiences of three years of teaching of the graduate course Model-Driven Software Development at Bilkent University in Turkey. The lessons learned can be useful for peer educators who teach or aim to teach a similar course. [ABSTRACT FROM PUBLISHER]

Abstract: Ambient Intelligence (AmI) requires Question Answering (QA) systems for providing intuitive interfaces to state natural language questions and obtaining precise answers related to some specific topic. Therefore, adapting QA systems to new restricted domains is an increasingly necessity for these systems to be applied in AmI environments. Unfortunately, research addressing adaptation of QA systems to new domains has two main drawbacks: (i) QA systems are manually tuned, which requires a huge effort in time and cost, and (ii) tuning of QA systems depends on the specific representation scheme of the restricted-domain knowledge, thus hinders incorporation of new resources into the system. To overcome these drawbacks, this paper presents a novel approach based on model-driven development in order to seamlessly integrate textual information and knowledge resources to automatically and effortlessly adapt QA systems to be useful for restricted-domain AmI environments, such as e-Science. [Copyright &y& Elsevier]

A Question Answering (QA) system must provide concise answers from large collections of documents to questions stated by the user in natural language. However, although many QA systems for open domain exist, its adaptation for restricted domains (such as those of healthcare, agriculture, transportation, or science) is a far from trivial task. The principal problem is that domain experts ask more precise questions (and expect more precise answers), including specific terminology, and this is costly to integrate into a QA system. To overcome this drawback, this paper presents an innovative approach based on model-driven software development. It uses restricted-domain resources to automatically and effortlessly adapt open-domain QA systems in order to make them useful in restricted-domain scenarios. Finally, a set of experiments has been carried out to show the approach's applicability. [ABSTRACT FROM AUTHOR]