{"id":12240,"date":"2024-04-29T10:56:49","date_gmt":"2024-04-29T08:56:49","guid":{"rendered":"https:\/\/www.iese.fraunhofer.de\/blog\/?p=12240"},"modified":"2024-04-29T10:56:49","modified_gmt":"2024-04-29T08:56:49","slug":"simplifying-simulation-scenario-with-yaml","status":"publish","type":"post","link":"https:\/\/www.iese.fraunhofer.de\/blog\/simplifying-simulation-scenario-with-yaml\/","title":{"rendered":"Simplifying Simulation Scenario Design and Execution: A Guide to Creating and Configuring FERAL Simulation Scenarios with YAML"},"content":{"rendered":"

Introduction<\/strong><\/h2>\n

Creating and configuring simulation scenarios is effort-intensive and time-consuming, mainly because each scenario requires a unique set of configurations, parameters, and settings, making the procedure time-consuming and error-prone. This complexity not only reduces productivity but also increases the learning curve for simulation specifiers and designers.<\/p>\n

What if there was a way to streamline this process, making simulation specification and configuration as straightforward as editing a simple text file?<\/p>\n

For that, we have a straightforward solution: a YAML<\/strong><\/a> file that describes the scenario without having to write a single line of a program statement.<\/span> <\/strong>By leveraging YAML for simulation specification and configuration, we introduce a technique that simplifies the initial simulation configuration and adjustments of simulation parameters.<\/p>\n

The objective of this blog post is to examine the approach and solution in depth, providing simulation designers and specifiers with a step-by-step guide, the challenges this approach tackles, and the solutions it offers. From experienced developers looking to boost productivity to newbies interested in simulation specification and configuration, this guide will provide the information and tools needed to set up their simulation in FERAL<\/a>.<\/p>\n

The challenge of simulation configuration<\/strong><\/h2>\n

We have identified the following challenges regarding the design and configuration of simulations:<\/p>\n

Complexity and Time Consumption<\/h3>\n

One of the primary challenges in simulation scenario creation and configuration is its inherent complexity [7]. Developers must specify numerous parameters, from environmental variables and entity behaviors to interaction rules and initial conditions [3, 5]. For example, environmental parameters such as temperature must be carefully set to match real-world conditions for a climate model, affecting weather patterns and ecosystem responses. Similarly, in urban simulations, traffic flow parameters must reflect peak and off-peak conditions to study congestion and optimize traffic signals accurately. In healthcare simulations, parameters like disease spread rates and patient immune responses must be accurately modeled to predict outcomes under various public health interventions. Furthermore, in automotive bus system simulations, the meticulous setting of parameters such as signal propagation time and bus load percentage is crucial for the evaluation of system performance in high-traffic scenarios. Also, fault injection rates and response times are critical parameters that must be precisely defined to assess the robustness of the bus system against potential errors or failures. The requirement to manually program these simulation models and their associated parameter configurations, which frequently necessitates a thorough understanding of the simulation framework’s architecture and syntax [4, 8], further complicates these issues. For instance, consider the challenge of learning and applying C++ to develop a simulation for a CAN bus system using the ns-3<\/a> network simulator. This task demands not only a grasp of basic programming knowledge of C++ but also a deep understanding of both the ns-3 architecture and the specific protocols and behaviors of the CAN network. As a result, the modeling and configuration process takes longer, slowing down the development cycle and causing testing and deployment delays.<\/p>\n

Error-Prone Processes<\/h3>\n

Manual configuration is also prone to errors [1]. A misplaced comma, an incorrect value, or an improperly defined entity can lead to simulation errors that are difficult to diagnose and correct. These errors can significantly impact a simulation’s validity, leading to inaccurate results or, in the worst-case scenario, complete simulation failure.<\/p>\n

Accessibility for New Users<\/h3>\n

For newcomers, the steep learning curve associated with understanding both the simulation framework and the syntax for its specification and configuration can be daunting. This can deter potential users and limit the diversity of perspectives and expertise in the simulation development community.<\/p>\n

The Need for a Solution<\/h3>\n

Given these challenges, there is a clear need for a solution that simplifies the simulation specification and configuration process [6], making it more accessible, efficient, and error-free. Such a solution would not only accelerate the development cycle but also enhance the quality and reliability of simulation outcomes. In this context, YAML exhibits potential as an exciting new approach to simulation specification and configuration when paired with smart tooling.<\/p>\n

Choosing YAML for configuration<\/b><\/h2>\n

Human-Readable Format<\/h3>\n

YAML’s design prioritizes human readability and ease of understanding. Its syntax is intuitive, making it accessible even to those new to simulation development. In contrast to alternative data serialization formats that may present challenges in terms of understandability and readability for human users, YAML’s well-defined structure enables users to effortlessly define complex scenarios and configurations without getting lost in syntactic complexities. This readability significantly reduces the learning curve for new users and decreases the likelihood of errors in configuration files.<\/p>\n

Below is a simple example of a YAML file that configures a basic web server environment with a description for each key.<\/p>\n

<\/p>\n

Figure 1: An example YAML file<\/strong><\/p>\n

The above YAML illustrates a configuration for a basic web server, segmented into two primary sections: server and security. In the „server“ section, details such as the server’s IP address, port number, maximum number of clients it can manage simultaneously, the server’s name, and whether the server is active are specified. Each setting is clearly labeled by a key<\/strong>, such as `host`, `port`, or `enabled`, followed by the corresponding value<\/strong>. Comments<\/strong> introduced with the `#` symbol explain the purpose of each setting, enhancing clarity and ease of use. The „security“ section outlines security-related settings, specifying whether SSL is enabled for secure communication and the location of the SSL certificate file. This structure, with keys followed by values and supplemented by descriptive comments, makes the YAML file straightforward and easy to maintain, demonstrating why YAML is favored for configuration files.<\/p>\n

Hierarchical Structure<\/h3>\n

Simulations often involve nested configurations, where entities are defined with various attributes that may also contain their configurations. YAML naturally supports hierarchical data representation, making it an excellent fit for defining the multi-layered settings of simulations. This feature allows developers to organize configurations in a way that mirrors the logical structure of the simulation, enhancing clarity and maintainability.<\/p>\n

Facilitating Collaboration and Standardization<\/h3>\n

YAML’s simplicity and readability extend beyond individual developers to teams and communities. It promotes collaboration by making configurations simple for all team members to share, review, and comprehend, regardless of their position or level of expertise. Furthermore, the use of YAML encourages standardization of configuration files across projects, promoting best practices and consistency in simulation development.<\/p>\n

Bridging the Gap for Simulation Model Designers<\/h3>\n

For designers of simulation models, YAML provides a flexible and straightforward means to develop configurable models. By defining model parameters and behaviors in YAML, designers can create templates that users can easily customize, lowering the barrier to entry for utilizing advanced simulations and enabling a wider range of applications.<\/p>\n

Enhancing YAML with intelligent tooling for simulation in FERAL<\/strong><\/h2>\n

The choice of YAML for simulation configuration brings numerous benefits, but when paired with intelligent tooling, its potential is fully unlocked. This section explores how tools like IntelliJ IDEA<\/a> by JetBrains or Visual Studio Code<\/a> by Microsoft integrated with the RedHat YAML plugin for Visual Studio Code<\/a> and the SnakeYAML <\/a>parser enhance the YAML experience, making simulation configuration more efficient, error-resistant, and user-friendly. In this regard, we have developed a simulation specification and configuration environment for the simulation framework FERAL (Framework for Evaluation on Requirements and Architecture Level) <\/a>[2]\u200b. The integration of these technologies with FERAL offers auto-completion, validation, and direct feedback within the IDE, resulting in a notable decrease in the potential for errors and an expedited configuration procedure.<\/p>\n

Intelligent Code Completion and Validation<\/h3>\n

One of the most significant advantages of using intelligent tooling with YAML is the support for intelligent code completion and validation. These features guide users through the creation of configuration files, suggesting possible completions and flagging errors in real-time. This not only accelerates the development process but also minimizes the risk of misconfigurations that could lead to simulation failures.<\/p>\n

Auto-Completion<\/h3>\n

With auto-completion, simulation specifiers and designers no longer need to memorize the exact structure of the configuration files, or the specific attributes required for each simulation component. The tooling suggests the available options as they type, based on the context and the schema of the simulation configuration. This feature is particularly beneficial for complex simulations with numerous parameters, reducing the cognitive load on the specifier and ensuring that all necessary configurations are accurately specified.<\/p>\n

Real-Time Validation<\/h3>\n

Real-time validation continuously checks the YAML file against the defined schema, immediately highlighting any discrepancies, such as missing required fields, incorrect data types, or values out of the allowed range. This instant feedback allows developers to correct issues on the fly, long before the simulation is run, thereby avoiding time-consuming debugging sessions.<\/p>\n

Simplifying Complex Configurations<\/h3>\n

Simulations often involve complex setups with nested configurations and dependencies between components. Intelligent tooling simplifies the management of these complex configurations by providing a clear and interactive interface. Developers can easily navigate through the layers of the configuration, understand the relationships between components, and make changes with confidence, knowing that the tooling will alert them to any inconsistencies.<\/p>\n

Documentation and Learning Support<\/h3>\n

Intelligent tooling often includes integrated documentation and tool tips, offering instant access to information about the configuration options and their implications. This embedded guidance is invaluable for learning and reference, enabling developers to understand the full capabilities of the simulation software without constantly referring to external documentation.<\/p>\n

Facilitating Collaboration and Standardization<\/h3>\n

By leveraging intelligent tooling, teams can ensure consistency and standardization across their simulation projects. The tooling can enforce predefined schemas and configuration standards, making it easier for team members to collaborate effectively, share configuration templates, and maintain an elevated level of quality and reliability in their simulations.<\/p>\n

Step-by-step guide for configuring a simulation in FERAL<\/strong><\/h2>\n

Configuring a simulation in FERAL is designed to be a straightforward process, thanks to its YAML-based configuration system and the support of intelligent tooling. This guide will walk you through the steps to configure a simulation scenario in FERAL using IntelliJ IDEA and the FERAL schema for validation.<\/p>\n

Step 1: Setting Up Your Environment<\/h3>\n

Before you begin, ensure that you have the FERAL jar file added to your project in IntelliJ IDEA. This jar file contains the necessary libraries and dependencies to run FERAL simulations. Additionally, if you have not done so already, install the Red Hat YAML plugin if you are using VS Code, or use IntelliJ IDEA, which does not require any additional plugin. These IDEs provide enhanced YAML editing experience with features like auto-completion and real-time validation. In IntelliJ IDEA, the setup looks like below:<\/p>\n

<\/p>\n

Figure 2: FERAL 3GP configuration setup in IntelliJ IDEA<\/strong><\/p>\n

Step 2: Creating Your YAML Configuration File<\/h3>\n

Start by creating a new file with a .yaml<\/strong> extension in your project directory (feral1.yaml<\/strong> file in Figure 2<\/strong>). This file will contain the configuration for your simulation scenario. The structure of the file will define various aspects of the simulation, such as the components involved, their configurations, and the interactions between them.<\/p>\n

Step 3: Writing Your Simulation Scenario<\/h3>\n

With your environment set up and your YAML file ready, you can start defining your simulation scenario. As you type, VS Code or IntelliJ IDEA and the FERAL schema will offer auto-completion suggestions and highlight any errors or inconsistencies in real-time. This immediate feedback allows you to correct issues as they arise, ensuring your configuration aligns with. Figure 3<\/strong> depicts an example simulation specified in YAML to simulate a CAN BUS network.<\/p>\n

<\/p>\n

Figure 3: A simple CAN bus network simulation specification in FERAL<\/strong><\/p>\n

Auto-Completion<\/strong>: As you begin typing in the YAML file, the IDE will suggest possible keys (parameters of the FERAL simulation) based on the schema. This feature is incredibly helpful for discovering the configuration options available in FERAL and ensuring you are using valid parameters. Figure 4 <\/strong>depicts how the auto-completion looks like in IntelliJ IDEA.<\/p>\n

<\/p>\n

Figure 4: FERAL auto-completion in simulation scenario specification<\/strong><\/p>\n

Validation and Error Reporting:<\/strong> If there are any discrepancies in your configuration, such as missing required components or incorrect value types, VS Code or IntelliJ IDEA will underline those errors (Figure 5)<\/strong>. Hovering over the errors will provide a detailed description of the issue and possible solutions, guiding you towards a valid simulation configuration.<\/p>\n

<\/p>\n

Figure 5: FERAL simulation scenario validation checks in YAML<\/strong><\/p>\n

Step 4: Running Your Simulation<\/h3>\n

Once your YAML configuration file is complete and free of errors, you are ready to run your simulation. FERAL provides the following command to execute the simulation:<\/p>\n

java -jar feral-0.4.0.jar –yaml feral1.yaml<\/strong><\/p>\n

and allows checking the results of the scenario in the console of the IDE.<\/p>\n

This step-by-step guide simplifies the process of configuring simulations in FERAL, making it accessible to users with varying levels of programming expertise. By leveraging the power of YAML and intelligent tooling, FERAL democratizes simulation design, allowing more users to participate in the creation and analysis of embedded system simulations.<\/p>\n

Use case: A real-world example with FERAL<\/strong><\/h2>\n

In this section, we will explore a practical example of configuring a CAN bus simulation using FERAL. This scenario demonstrates how FERAL’s YAML-based configuration allows for the detailed specification of simulation parameters, including the simulation environment, network components, and fault conditions. The goal is to simulate a network with a single CAN node (can0) that experiences a link failure, affecting message transmission for a specified duration.<\/p>\n

Scenario Overview<\/h3>\n

Here we will consider the simulation scenario defined in Figure 3<\/strong>. The scenario is designed to run for 10 seconds<\/strong>, during which a producer (prod)<\/strong> generates messages at a regular interval of 1 second<\/strong>. These messages are intended for node0<\/strong> on the CAN bus (can0)<\/strong>. However, a fault injector is configured to simulate a sender link failure between seconds 3<\/strong> and 6<\/strong>, resulting in dropped frames during this period.<\/p>\n

Configuration Breakdown<\/h3>\n

Simulation Duration<\/strong>: The simulation is set to be executed for 10 seconds<\/strong>, providing a concise window to observe the fault injection’s impact.<\/p>\n

Directors:<\/strong> A single director named root is defined with a DISCRETE_EVENT<\/strong> type, orchestrating the simulation’s event-driven behavior.<\/p>\n

CAN Configuration:<\/strong> The CAN network configuration specifies one node (node0)<\/strong> under the can0<\/strong> network, managed by the root director. This node is configured not to drop duplicate frames, allowing for a straightforward analysis of the fault injector’s effect.<\/p>\n

Fault Injectors:<\/strong> node0<\/strong> is equipped with a fault injector configured to simulate a sender link failure (SENDER_LINK_FAILURE)<\/strong> by dropping frames (DROP_FRAME)<\/strong> from seconds 3<\/strong> to 6<\/strong> of the simulation. This setup provides a clear example of how network faults can be simulated and studied within FERAL.<\/p>\n

Producers:<\/strong> A producer named prod is defined to generate messages with an initial value of 1, which is incremented by 1<\/strong> at each interval of 1 second<\/strong>. This producer is linked to node0<\/strong>, simulating a data source for the node.<\/p>\n

Links:<\/strong> The configuration establishes a link between the producer’s output and node0<\/strong>’s input port named apple, facilitating the flow of messages into the CAN network.<\/p>\n

Executing the Simulation<\/h3>\n

To execute this simulation, users can simply create a YAML file (as in Figure 3<\/strong>) and utilize FERAL’s simulation execution command described in Step\u00a04<\/strong> of the previous section. As the simulation progresses, users can check the result in the console of the IDE (Figure 6)<\/strong>, observe the normal operation of message transmission, the effect of the fault injector during the specified interval (if any), and the resumption of normal operation after the fault condition ends.<\/p>\n

<\/p>\n

Figure 6: Execution result of FERAL CAN bus network simulation<\/strong><\/p>\n

This use case exemplifies the power and flexibility of FERAL for simulating complex embedded systems and their behaviors under various conditions. By leveraging YAML for configuration, FERAL makes it possible to design, execute, and analyze simulations without deep programming knowledge, opening the field of embedded system simulation to a broader audience.<\/p>\n

Conclusion<\/h2>\n

The journey from conceptualizing a simulation scenario to its successful execution involves numerous steps, each with its own set of challenges and complexities. By adopting YAML for simulation configuration, we significantly streamline this process, making it more accessible, efficient, and error-resistant. YAML’s human-readable format, combined with the power of intelligent tooling like the Red Hat YAML plugin for VS Code, transforms the way simulations are designed and executed.<\/p>\n

This approach not only simplifies simulation design, allowing individuals without deep programming expertise to configure and run complex simulations, but also enhances collaboration among team members. With the ability to validate configurations on the fly, designers can catch and correct errors early in the development process, saving time and resources that would otherwise be spent debugging simulations post-execution.<\/p>\n

Moreover, the adoption of best practices in YAML configuration ensures that simulations are not only correctly set up but also optimized for performance and maintainability. By organizing and documenting simulation configurations effectively, teams can build a robust library of scenarios that can be reused and adapted for future projects, further accelerating the simulation development cycle.<\/p>\n

In conclusion, the incorporation of YAML configurations into simulation environments like FERAL, along with intelligent IDE tooling and adherence to best practices, represents a significant advancement in simulation technology. It empowers engineers, researchers, and educators to more easily harness the power of simulations to explore, validate, and demonstrate complex systems and phenomena. As we continue to evolve these tools and practices, the potential for innovation in simulation-driven fields is boundless, promising ever more sophisticated and insightful outcomes.<\/p>\n

References<\/h2>\n
    \n
  1. Hoseini, S., Hamou-Lhadj, A., Desrosiers, P., &\u00a0Tapp, M. (05312014). Software feature location in practice: debugging aircraft simulation systems. In P. Jalote, L. Briand, & A. van der Hoek (Eds.), ICSE ’14: 36th International Conference on Software Engineering, Hyderabad India, 31 05 2014 07 06 2014<\/em> (pp. 225\u2013234). New York, NY, USA:\u00a0ACM. doi:10.1145\/2591062.2591192.<\/li>\n
  2. (2013). Kuhn, T., Forster, T., Braun, T., Gotzhein, R.: FERAL \u2013 framework for simulator coupling on requirements and architecture level. In: Proceedings of the 11th ACM-IEEE International Conference on Formal Methods and Models for System Design (MEMOCODE \u201813), Portland (Oregon), USA (2013) .<\/li>\n
  3. Mehlhase, A., J\u00e4hnichen, S., Czwink, A., &\u00a0Heinrichs, R. (1988). A Library and Scripting Language for Tool Independent Simulation Descriptions. In G. Marinucci (Ed.), Tecniche costruttive romane<\/em> (Vol. 9952, pp. 622\u2013638, Pubblicazioni dei gruppi archeologici d’italia, Vol. 32). Roma:\u00a0Gruppo archeologico romano.<\/li>\n
  4. Reif, J., Jeleniewski, T., &\u00a0Fay, A. (uuuu-uuuu). An Approach to Automating the Generation of Process Simulation Sequences. In 2023 IEEE 28th International Conference on Emerging Technologies and Factory Automation (ETFA), Sinaia, Romania, 9\/12\/2023 – 9\/15\/2023<\/em> (pp. 1\u20134):\u00a0IEEE. doi:10.1109\/ETFA54631.2023.10275718.<\/li>\n
  5. Schutzel, J., Peng, D., Uhrmacher, A. M., &\u00a0Perrone, L. F. (2014 – 2014). Perspectives on languages for specifying simulation experiments. In 2014 Winter Simulation Conference – (WSC 2014), Savanah, GA, USA, 12\/7\/2014 – 12\/10\/2014<\/em> (pp. 2836\u20132847):\u00a0IEEE. doi:10.1109\/WSC.2014.7020125.<\/li>\n
  6. van der Zee, D.-J., Tako, A., Robinson, S., Fishwick, P., &\u00a0Rose, O. (2018?). PANEL: EDUCATION ON SIMULATION MODEL SIMPLIFICATION \u2013 BEYOND RULES OF THUMB. In 2018 Winter Simulation Conference (WSC), Gothenburg, Sweden, 12\/9\/2018 – 12\/12\/2018<\/em> (pp. 3987\u20134001). [Piscataway, NJ]:\u00a0IEEE. doi:10.1109\/WSC.2018.8632544.<\/li>\n
  7. van Mierlo, S., Vangheluwe, H., &\u00a0Denil, J. (2019). The Fundamentals of Domain-Specific Simulation Language Engineering. In 2019 Winter Simulation Conference (WSC), National Harbor, MD, USA, 12\/8\/2019 – 12\/11\/2019<\/em> (pp. 1482\u20131494, ACM Digital Library). [Erscheinungsort Nacht ermittelbar]:\u00a0IEEE Press. doi:10.1109\/WSC40007.2019.9004726.<\/li>\n
  8. Wagner, G. (2016 – 2016). Introduction to simulation using JavaScript. In 2016 Winter Simulation Conference (WSC), Washington, DC, USA, 12\/11\/2016 – 12\/14\/2016<\/em> (pp. 148\u2013162):\u00a0IEEE. doi:10.1109\/WSC.2016.7822086.<\/li>\n<\/ol>\n","protected":false},"excerpt":{"rendered":"

    Introduction Creating and configuring simulation scenarios is effort-intensive and time-consuming, mainly because each scenario requires a unique set of configurations, parameters, and settings, making the procedure time-consuming and error-prone. This complexity not only reduces productivity but also increases the learning…<\/p>\n","protected":false},"author":155,"featured_media":12291,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[239,94],"tags":[233,477],"coauthors":[656,379],"class_list":["post-12240","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-autonomes-fahren","category-industrie-4-0","tag-software-engineering","tag-virtual-engineering"],"yoast_head":"\nSimplifying Simulation Scenario Design and Execution: A Guide to Creating and Configuring FERAL Simulation Scenarios with YAML - Blog des Fraunhofer IESE<\/title>\n<meta name=\"description\" content=\"Simplifying simulation scenarios with YAML: boundless potential for innovation in simulation-driven fields and insightful outcomes.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.iese.fraunhofer.de\/blog\/simplifying-simulation-scenario-with-yaml\/\" \/>\n<meta property=\"og:locale\" content=\"de_DE\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Simplifying Simulation Scenario Design and Execution: A Guide to Creating and Configuring FERAL Simulation Scenarios with YAML - Blog des Fraunhofer IESE\" \/>\n<meta property=\"og:description\" content=\"Simplifying simulation scenarios with YAML: boundless potential for innovation in simulation-driven fields and insightful outcomes.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.iese.fraunhofer.de\/blog\/simplifying-simulation-scenario-with-yaml\/\" \/>\n<meta property=\"og:site_name\" content=\"Fraunhofer IESE\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/FraunhoferIESE\/\" \/>\n<meta property=\"article:published_time\" content=\"2024-04-29T08:56:49+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/www.iese.fraunhofer.de\/blog\/wp-content\/uploads\/2024\/04\/virtual-engineering-yaml.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"1194\" \/>\n\t<meta property=\"og:image:height\" content=\"599\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"Priom Biswas, Dr.-Ing. Pablo Oliveira Antonino\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@FraunhoferIESE\" \/>\n<meta name=\"twitter:site\" content=\"@FraunhoferIESE\" \/>\n<meta name=\"twitter:label1\" content=\"Verfasst von\" \/>\n\t<meta name=\"twitter:data1\" content=\"Priom Biswas\" \/>\n\t<meta name=\"twitter:label2\" content=\"Gesch\u00e4tzte Lesezeit\" \/>\n\t<meta name=\"twitter:data2\" content=\"15\u00a0Minuten\" \/>\n\t<meta name=\"twitter:label3\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data3\" content=\"Priom Biswas, Dr.-Ing. Pablo Oliveira Antonino\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/simplifying-simulation-scenario-with-yaml\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/simplifying-simulation-scenario-with-yaml\\\/\"},\"author\":{\"name\":\"Priom Biswas\",\"@id\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/#\\\/schema\\\/person\\\/cabcdb5567537344000f09d06cd10316\"},\"headline\":\"Simplifying Simulation Scenario Design and Execution: A Guide to Creating and Configuring FERAL Simulation Scenarios with YAML\",\"datePublished\":\"2024-04-29T08:56:49+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/simplifying-simulation-scenario-with-yaml\\\/\"},\"wordCount\":3118,\"publisher\":{\"@id\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/simplifying-simulation-scenario-with-yaml\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/wp-content\\\/uploads\\\/2024\\\/04\\\/virtual-engineering-yaml.jpg\",\"keywords\":[\"Software Engineering\",\"Virtual Engineering\"],\"articleSection\":[\"Autonomes Fahren\",\"Industrie 4.0\"],\"inLanguage\":\"de\"},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/simplifying-simulation-scenario-with-yaml\\\/\",\"url\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/simplifying-simulation-scenario-with-yaml\\\/\",\"name\":\"Simplifying Simulation Scenario Design and Execution: A Guide to Creating and Configuring FERAL Simulation Scenarios with YAML - Blog des Fraunhofer IESE\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/simplifying-simulation-scenario-with-yaml\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/simplifying-simulation-scenario-with-yaml\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/wp-content\\\/uploads\\\/2024\\\/04\\\/virtual-engineering-yaml.jpg\",\"datePublished\":\"2024-04-29T08:56:49+00:00\",\"description\":\"Simplifying simulation scenarios with YAML: boundless potential for innovation in simulation-driven fields and insightful outcomes.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/simplifying-simulation-scenario-with-yaml\\\/#breadcrumb\"},\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/simplifying-simulation-scenario-with-yaml\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/simplifying-simulation-scenario-with-yaml\\\/#primaryimage\",\"url\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/wp-content\\\/uploads\\\/2024\\\/04\\\/virtual-engineering-yaml.jpg\",\"contentUrl\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/wp-content\\\/uploads\\\/2024\\\/04\\\/virtual-engineering-yaml.jpg\",\"width\":1194,\"height\":599,\"caption\":\"Simplifying simulation scenarios with YAML\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/simplifying-simulation-scenario-with-yaml\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Startseite\",\"item\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Simplifying Simulation Scenario Design and Execution: A Guide to Creating and Configuring FERAL Simulation Scenarios with YAML\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/#website\",\"url\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/\",\"name\":\"Fraunhofer IESE\",\"description\":\"Blog des Fraunhofer-Institut f\u00fcr Experimentelles Software Engineering\",\"publisher\":{\"@id\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"de\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/#organization\",\"name\":\"Fraunhofer IESE\",\"url\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/wp-content\\\/uploads\\\/2016\\\/08\\\/fhg_iese_logo.png\",\"contentUrl\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/wp-content\\\/uploads\\\/2016\\\/08\\\/fhg_iese_logo.png\",\"width\":183,\"height\":50,\"caption\":\"Fraunhofer IESE\"},\"image\":{\"@id\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\"},\"sameAs\":[\"https:\\\/\\\/www.facebook.com\\\/FraunhoferIESE\\\/\",\"https:\\\/\\\/x.com\\\/FraunhoferIESE\",\"https:\\\/\\\/www.linkedin.com\\\/company\\\/fraunhoferiese\\\/\",\"https:\\\/\\\/www.youtube.com\\\/c\\\/FraunhoferIESE\"]},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/#\\\/schema\\\/person\\\/cabcdb5567537344000f09d06cd10316\",\"name\":\"Priom Biswas\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/wp-content\\\/uploads\\\/2024\\\/04\\\/BiswasPriom_Portrait_01_Detail-96x96.jpgb06d9558647f9e46f4f5f99d450b611b\",\"url\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/wp-content\\\/uploads\\\/2024\\\/04\\\/BiswasPriom_Portrait_01_Detail-96x96.jpg\",\"contentUrl\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/wp-content\\\/uploads\\\/2024\\\/04\\\/BiswasPriom_Portrait_01_Detail-96x96.jpg\",\"caption\":\"Priom Biswas\"},\"description\":\"Priom Biswas received his Master\u2019s degree in Computer Science from the Technical University of Kaiserslautern in 2022. Since 2020, he has been working at the Fraunhofer Institute for Experimental Software Engineering IESE in Kaiserslautern. Prior to joining the institute, he garnered more than three years of professional experience as a software engineer in Bangladesh. Here at Fraunhofer IESE, he has the role of a software architect and researcher in the Virtual Engineering department. Together with his team, he develops and tests solutions for the FERAL simulation framework. His research focuses on the specialized domains of software architecture, continuous engineering, and simulation. -- Priom Biswas machte 2022 seinen Masterabschluss in Informatik an der Technischen Universit\u00e4t Kaiserslautern. Seit 2020 arbeitet er am Fraunhofer-Institut f\u00fcr Experimentelles Software Engineering IESE in Kaiserslautern. Vor seiner Zeit am Institut sammelte er mehr als drei Jahre Berufserfahrung als Software Engineer in Bangladesh. Hier am Fraunhofer IESE ist er als Softwarearchitekt und wissenschaftlicher Mitarbeiter in der Abteilung Virtual Engineering t\u00e4tig. Zusammen mit seinem Team entwickelt und testet er L\u00f6sungen f\u00fcr das Simulationsframework FERAL. Seine Forschungsschwerpunkte liegen in den Fachgebieten Softwarearchitektur, Continuous Engineering und Simulation.\",\"url\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/author\\\/priom-biswas\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Simplifying Simulation Scenario Design and Execution: A Guide to Creating and Configuring FERAL Simulation Scenarios with YAML - Blog des Fraunhofer IESE","description":"Simplifying simulation scenarios with YAML: boundless potential for innovation in simulation-driven fields and insightful outcomes.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.iese.fraunhofer.de\/blog\/simplifying-simulation-scenario-with-yaml\/","og_locale":"de_DE","og_type":"article","og_title":"Simplifying Simulation Scenario Design and Execution: A Guide to Creating and Configuring FERAL Simulation Scenarios with YAML - Blog des Fraunhofer IESE","og_description":"Simplifying simulation scenarios with YAML: boundless potential for innovation in simulation-driven fields and insightful outcomes.","og_url":"https:\/\/www.iese.fraunhofer.de\/blog\/simplifying-simulation-scenario-with-yaml\/","og_site_name":"Fraunhofer IESE","article_publisher":"https:\/\/www.facebook.com\/FraunhoferIESE\/","article_published_time":"2024-04-29T08:56:49+00:00","og_image":[{"width":1194,"height":599,"url":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-content\/uploads\/2024\/04\/virtual-engineering-yaml.jpg","type":"image\/jpeg"}],"author":"Priom Biswas, Dr.-Ing. Pablo Oliveira Antonino","twitter_card":"summary_large_image","twitter_creator":"@FraunhoferIESE","twitter_site":"@FraunhoferIESE","twitter_misc":{"Verfasst von":"Priom Biswas","Gesch\u00e4tzte Lesezeit":"15\u00a0Minuten","Written by":"Priom Biswas, Dr.-Ing. Pablo Oliveira Antonino"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.iese.fraunhofer.de\/blog\/simplifying-simulation-scenario-with-yaml\/#article","isPartOf":{"@id":"https:\/\/www.iese.fraunhofer.de\/blog\/simplifying-simulation-scenario-with-yaml\/"},"author":{"name":"Priom Biswas","@id":"https:\/\/www.iese.fraunhofer.de\/blog\/#\/schema\/person\/cabcdb5567537344000f09d06cd10316"},"headline":"Simplifying Simulation Scenario Design and Execution: A Guide to Creating and Configuring FERAL Simulation Scenarios with YAML","datePublished":"2024-04-29T08:56:49+00:00","mainEntityOfPage":{"@id":"https:\/\/www.iese.fraunhofer.de\/blog\/simplifying-simulation-scenario-with-yaml\/"},"wordCount":3118,"publisher":{"@id":"https:\/\/www.iese.fraunhofer.de\/blog\/#organization"},"image":{"@id":"https:\/\/www.iese.fraunhofer.de\/blog\/simplifying-simulation-scenario-with-yaml\/#primaryimage"},"thumbnailUrl":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-content\/uploads\/2024\/04\/virtual-engineering-yaml.jpg","keywords":["Software Engineering","Virtual Engineering"],"articleSection":["Autonomes Fahren","Industrie 4.0"],"inLanguage":"de"},{"@type":"WebPage","@id":"https:\/\/www.iese.fraunhofer.de\/blog\/simplifying-simulation-scenario-with-yaml\/","url":"https:\/\/www.iese.fraunhofer.de\/blog\/simplifying-simulation-scenario-with-yaml\/","name":"Simplifying Simulation Scenario Design and Execution: A Guide to Creating and Configuring FERAL Simulation Scenarios with YAML - Blog des Fraunhofer IESE","isPartOf":{"@id":"https:\/\/www.iese.fraunhofer.de\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.iese.fraunhofer.de\/blog\/simplifying-simulation-scenario-with-yaml\/#primaryimage"},"image":{"@id":"https:\/\/www.iese.fraunhofer.de\/blog\/simplifying-simulation-scenario-with-yaml\/#primaryimage"},"thumbnailUrl":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-content\/uploads\/2024\/04\/virtual-engineering-yaml.jpg","datePublished":"2024-04-29T08:56:49+00:00","description":"Simplifying simulation scenarios with YAML: boundless potential for innovation in simulation-driven fields and insightful outcomes.","breadcrumb":{"@id":"https:\/\/www.iese.fraunhofer.de\/blog\/simplifying-simulation-scenario-with-yaml\/#breadcrumb"},"inLanguage":"de","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.iese.fraunhofer.de\/blog\/simplifying-simulation-scenario-with-yaml\/"]}]},{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/www.iese.fraunhofer.de\/blog\/simplifying-simulation-scenario-with-yaml\/#primaryimage","url":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-content\/uploads\/2024\/04\/virtual-engineering-yaml.jpg","contentUrl":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-content\/uploads\/2024\/04\/virtual-engineering-yaml.jpg","width":1194,"height":599,"caption":"Simplifying simulation scenarios with YAML"},{"@type":"BreadcrumbList","@id":"https:\/\/www.iese.fraunhofer.de\/blog\/simplifying-simulation-scenario-with-yaml\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Startseite","item":"https:\/\/www.iese.fraunhofer.de\/blog\/"},{"@type":"ListItem","position":2,"name":"Simplifying Simulation Scenario Design and Execution: A Guide to Creating and Configuring FERAL Simulation Scenarios with YAML"}]},{"@type":"WebSite","@id":"https:\/\/www.iese.fraunhofer.de\/blog\/#website","url":"https:\/\/www.iese.fraunhofer.de\/blog\/","name":"Fraunhofer IESE","description":"Blog des Fraunhofer-Institut f\u00fcr Experimentelles Software Engineering","publisher":{"@id":"https:\/\/www.iese.fraunhofer.de\/blog\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.iese.fraunhofer.de\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"de"},{"@type":"Organization","@id":"https:\/\/www.iese.fraunhofer.de\/blog\/#organization","name":"Fraunhofer IESE","url":"https:\/\/www.iese.fraunhofer.de\/blog\/","logo":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/www.iese.fraunhofer.de\/blog\/#\/schema\/logo\/image\/","url":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-content\/uploads\/2016\/08\/fhg_iese_logo.png","contentUrl":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-content\/uploads\/2016\/08\/fhg_iese_logo.png","width":183,"height":50,"caption":"Fraunhofer IESE"},"image":{"@id":"https:\/\/www.iese.fraunhofer.de\/blog\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/FraunhoferIESE\/","https:\/\/x.com\/FraunhoferIESE","https:\/\/www.linkedin.com\/company\/fraunhoferiese\/","https:\/\/www.youtube.com\/c\/FraunhoferIESE"]},{"@type":"Person","@id":"https:\/\/www.iese.fraunhofer.de\/blog\/#\/schema\/person\/cabcdb5567537344000f09d06cd10316","name":"Priom Biswas","image":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-content\/uploads\/2024\/04\/BiswasPriom_Portrait_01_Detail-96x96.jpgb06d9558647f9e46f4f5f99d450b611b","url":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-content\/uploads\/2024\/04\/BiswasPriom_Portrait_01_Detail-96x96.jpg","contentUrl":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-content\/uploads\/2024\/04\/BiswasPriom_Portrait_01_Detail-96x96.jpg","caption":"Priom Biswas"},"description":"Priom Biswas received his Master\u2019s degree in Computer Science from the Technical University of Kaiserslautern in 2022. Since 2020, he has been working at the Fraunhofer Institute for Experimental Software Engineering IESE in Kaiserslautern. Prior to joining the institute, he garnered more than three years of professional experience as a software engineer in Bangladesh. Here at Fraunhofer IESE, he has the role of a software architect and researcher in the Virtual Engineering department. Together with his team, he develops and tests solutions for the FERAL simulation framework. His research focuses on the specialized domains of software architecture, continuous engineering, and simulation. -- Priom Biswas machte 2022 seinen Masterabschluss in Informatik an der Technischen Universit\u00e4t Kaiserslautern. Seit 2020 arbeitet er am Fraunhofer-Institut f\u00fcr Experimentelles Software Engineering IESE in Kaiserslautern. Vor seiner Zeit am Institut sammelte er mehr als drei Jahre Berufserfahrung als Software Engineer in Bangladesh. Hier am Fraunhofer IESE ist er als Softwarearchitekt und wissenschaftlicher Mitarbeiter in der Abteilung Virtual Engineering t\u00e4tig. Zusammen mit seinem Team entwickelt und testet er L\u00f6sungen f\u00fcr das Simulationsframework FERAL. Seine Forschungsschwerpunkte liegen in den Fachgebieten Softwarearchitektur, Continuous Engineering und Simulation.","url":"https:\/\/www.iese.fraunhofer.de\/blog\/author\/priom-biswas\/"}]}},"jetpack_featured_media_url":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-content\/uploads\/2024\/04\/virtual-engineering-yaml.jpg","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-json\/wp\/v2\/posts\/12240","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-json\/wp\/v2\/users\/155"}],"replies":[{"embeddable":true,"href":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-json\/wp\/v2\/comments?post=12240"}],"version-history":[{"count":15,"href":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-json\/wp\/v2\/posts\/12240\/revisions"}],"predecessor-version":[{"id":12337,"href":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-json\/wp\/v2\/posts\/12240\/revisions\/12337"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-json\/wp\/v2\/media\/12291"}],"wp:attachment":[{"href":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-json\/wp\/v2\/media?parent=12240"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-json\/wp\/v2\/categories?post=12240"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-json\/wp\/v2\/tags?post=12240"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-json\/wp\/v2\/coauthors?post=12240"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}