An overview on framework design for autonomous robots <s> Model-driven software development <s> The development of service robots has gained more and more attention over the last years. Advanced robots have to cope with many different situations and contingencies while executing concurrent and interruptable complex tasks. In particular, mobile manipulation tasks increase the complexity. To manage the raising number of tasks and execution variants in complex environments there is a tremendous need for context and situation dependent composition and selection of reusable skills. This requires explicit descriptions of relevant properties and parameters of the robot, its resources and its capabilities. Different views on partial aspects of a robot system (mechanical, electrical and even software) can be provided by different models as is already common practice at design-time. However, these design-time models also need to be accessible at run-time to support run-time reasoning of the robot in order to adequately compose its skills and assign resources. That requires to extract useful information out of the design-time models and to transform it into representations which can be exploited at runtime. We present an approach to exploit information provided via design-time models (e.g. software components, simulation, planning) for run-time decision making. It allows for more informed decisions on how to compose action plots at run-time in order to manage the huge amount of different execution variants in service robotics. <s> BIB001 </s> An overview on framework design for autonomous robots <s> Model-driven software development <s> Because robotic systems get more complex all the time, developers around the world have, during the last decade, created component-based software frameworks (Orocos, Open-RTM, ROS, OPRoS, SmartSoft) to support the development and reuse of "large grained" pieces of robotics software. This paper introduces the BRICS Component Model (BCM) to provide robotics developers with a set of guidelines, metamodels and tools for structuring as much as possible the development of, both, individual components and component-based architectures, using one or more of the aforementioned software frameworks at the same time, without introducing any framework- or application-specific details. The BCM is built upon two complementary paradigms: the "5Cs" (separation of concerns between the development aspects of Computation, Communication, Coordination, Configuration and Composition) and the meta-modeling approach from Model-Driven Engineering. <s> BIB002 </s> An overview on framework design for autonomous robots <s> Model-driven software development <s> The design, simulation and programming of robotics systems is challenging as expertise from multiple domains needs to be integrated conceptually and technically. Domain-specific modeling promises an efficient and flexible concept for developing robotics applications that copes with this challenge. It allows to raise the level of abstraction through the use of specific concepts that are closer to the respective domain concerns and easier to understand and validate. Furthermore, it focuses on increasing the level of automation, e.g. through code generation, to bridge the gap between the modeling and the implementation levels and to improve the efficiency and quality of the software development process. Within this contribution, we survey the literature available on domain-specific (modeling) languages in robotics required to realize a state-of-the-art real-world example from the [email protected] competition. We classify 41 publications in the field as reference for potential DSL users. Furthermore, we analyze these contributions from a DSL-engineering viewpoint and discuss quantitative and qualitative aspects such as the methods and tools used for DSL implementation as well as their documentation status and platform integration. Finally, we conclude with some recommendations for discussion in the robotics programming and simulation community based on the insights gained with this survey. <s> BIB003 </s> An overview on framework design for autonomous robots <s> Model-driven software development <s> This paper describes a Component-Based Meta-Model (WCOMM) and framework (FraCC) as part of a complete Model-Driven Software Development process and toolchain: C-Forge. The approach given in the design of WCOMM and FraCC is presented highlighting the differences with other similar approaches. To illustrate the use of C-Forge, the development of a control architecture for the robots in project MISSION is presented. <s> BIB004 </s> An overview on framework design for autonomous robots <s> Model-driven software development <s> The authors are part of a research group that had the opportunity (i) to develop a large software framework (±5 person year effort), (ii) to use that framework (“iTaSC”) on several dozen research applications in the context of the specification and execution of a wide spectrum of mobile manipulator tasks, (iii) to analyse not only the functionality and the performance of the software but also its readiness for reuse, composition and model-driven code generation, and, finally, (iv) to spend another 5 person years on re-design and refactoring. This paper presents our major lessons learned, in the form of two best practices that we identified, and are since then bringing into practice in any new software development: (i) the 5C meta model to realise separation of concerns (the concerns being Communication, Computation, Coordination, Configuration, and Composition), and (ii) the Composition Pattern as an architectural meta model supporting the methodological coupling of components developed along the lines of the 5Cs. These generic results are illustrated, grounded and motivated by what we learned from the huge efforts to refactor the iTaSC software, and are now behind all our other software development efforts, without any exception. In the concrete iTaSC case, the Composition Pattern is applied at three levels of (modelling) hierarchy: application, iTaSC, and task level, each of which consist itself of several components structured in conformance with the pattern. <s> BIB005
Model-Driven Software Development (MDSD) and DomainSpecific Languages (DSLs) are topics which gained increased research interest in recent years (e. g. BIB002  BIB003 ). Schlegel et al.  elaborately propose adopting MDSD approaches in robotics -as well as "model-centric robotic systems". Consequently, SmartSoft is based on model-driven concepts: Components are implemented in a platform-independent way. The MDSD toolchain can then be used to generate instances for specific implementations. Currently, there are two such implementations based on CORBA and ACE. Similarly, there is a platformindependent model for RT components (see Section 2.1) for use with any implementation of the OMG standard. In practice, however, many existing RT components depend on the headers of OpenRTM-aist implementation. GenoM3 ("Generator of Modules") is another notable approach that generates middleware-specific instances of middlewareindependent component artifacts. It allows, for instance, generating components for use in ROS. The workflow is illustrated in Figure 4 . Ortiz et al. BIB004 created the model-based toolchain "CForge". Instead of generating code, a model loader interprets models and instantiates components accordingly. Model-based approaches are also suitable for creating hard real-time applications, as several authors write  BIB004  . Apart from generating code, temporal models can be used to perform real-time schedulability analysis. Cheddar⁸ is a popular tool for this purpose. Steck et al. BIB001 show that design-time models can be exploited for reasoning at runtime -an aspect arguably of increasing importance towards "cognitive" robotics BIB005 . Domain-Specific Languages (DSLs) are a related topic. They are special-purpose languages targeting specific problem domains, enabling the concise expression of relevant artifacts. Nordmann et al. BIB003 provide a survey on the many approaches. According to Bäuml  , there are many areas in robotics that "[. . . ] would benefit from a specialized language which supports the respective abstractions also syntactically and so helps to avoid a lot of boiler plate code" -examples including the "kinematic/dynamic/geometrical description of a robot" or a "language for complex and concurrent state machines". Most DSLs are independent from a specific robotic framework. URBIScript  is a domain-specific scripting language for robotics included in the URBI framework. It supports finite state machines, parallelism and concurrency in a sophisticated way. aRDx  is a new framework particularly suitable for integration of DSLs. Implemented in the scripting language Racket⁹, it allows to "build whole towers of languages". Due to maintenance effort, Orocos recently switched from its own scripting language RTT to a Lua-based internal, real-time DSL  . A central use case are hierarchical state machines. Models can be used to verify certain properties of a system (model checking). This way, they can have an impact on various execution qualities of a system such as safety, responsiveness, robustness or functional correctness. Code generation provides chances to improve efficiency. Regarding evolution qualities, using models can contribute to e. g. maintainability and changeability, as well as overall development effort. However, MDSD and DSLs can also have drawbacks. Especially the development of a new, non-trivial meta model or DSL together with sufficiently mature code transformation and debugging facilities, requires a huge amount of effort -possibly much more than it saves in the end. Immature solutions are detrimental with respect to maintainability and changeability of systems BIB005 . Even mature code transformation and DSLs can complicate de-8 http://beru.univ-brest.fr/~singhoff/cheddar 9 http://racket-lang.org bugging. Notably, many solutions depend on the Eclipse platform BIB003 . The Finroc runtime environment can load and store application structure models (components, connections, and configuration) in XML files that may be generated, interpreted, and changed by external tools. In the context of behavior-based networks, model transformation and model checking approaches were realized  . Apart from that, adoption of existing approaches is intended. An experimental plugin adds support for the URBIScript language.