Search

Software and systems modeling (2023). doi:10.1007/s10270-023-01106-4, Published by Springer, New York, NY

Software and systems modeling 22(1), 1-7 (2023). doi:10.1007/s10270-023-01085-6, Published by Springer, Berlin ; Heidelberg ; New York, NY

Software and systems modeling 22(2), 449-451 (2023). doi:10.1007/s10270-023-01098-1, Published by Springer, Berlin ; Heidelberg ; New York, NY

Software and systems modeling 21(3), 839-841 (2022). doi:10.1007/s10270-022-01001-4, Published by Springer, Berlin

While LLMs can effectively help prototype single ML functionalities, many real-world applications involve complex tasks that cannot be easily handled via a single run of an LLM. Recent work has found that chaining multiple LLM runs together (with the output of one step being the input to the next) can help users accomplish these more complex tasks, and in a way that is perceived to be more transparent and controllable. However, it remains unknown what users need when authoring their own LLM chains -- a key step for lowering the barriers for non-AI-experts to prototype AI-infused applications. In this work, we explore the LLM chain authoring process. We conclude from pilot studies find that chaining requires careful scaffolding for transforming intermediate node outputs, as well as debugging the chain at multiple granularities; to help with these needs, we designed PromptChainer, an interactive interface for visually programming chains. Through case studies with four people, we show that PromptChainer supports building prototypes for a range of applications, and conclude with open questions on scaling chains to complex tasks, and supporting low-fi chain prototyping., CHI LBW 2022

Software and Systems Modeling 21(1), 1-7 (2022). doi:10.1007/s10270-022-00979-1, Published by Springer, New York, NY

Software and systems modeling 21(5), 1685-1686 (2022). doi:10.1007/s10270-022-01046-5, Published by Springer, Berlin ; Heidelberg ; New York, NY

Software and systems modeling (2022). doi:10.1007/s10270-022-01021-0, Published by Springer, New York, NY

Software and systems modeling 21(6), 2097-2099 (2022). doi:10.1007/s10270-022-01057-2, Published by Springer, New York, NY

Software and systems modeling 21(2), 435-436 (2022). doi:10.1007/s10270-022-00999-x, Published by Springer, Berlin ; Heidelberg , New York, NY

Model-based systems engineering (MBSE) enables to verify the system performance using system behavior models, which can identify design faults that do not meet the stakeholders' requirements as early as possible, thus reducing the R&D cost and error risks. Currently, different domain engineers make use of different modeling languages to create their own behavior models. Different behavior models are verified by different approaches. It is difficult to adopt a unified integrated platform to support the modeling and verification of heterogeneous behavior models during the conceptual design phase. This paper proposes a unified modeling and verification approach supporting system formalisms and verification. The KARMA language is used to support the unified formalisms across MBSE models and dynamic simulations for different domain specific models. In order to describe the behavior model more precisely and to facilitate verification, the syntax of hybrid automata is integrated into KARMA. We implemented behavior models and their verification in MetaGraph, a multi-architecture modeling tool. Finally, the effectiveness of the proposed approach is validated by two cases: 1) the scenario of booking railway tickets using BPMN models; 2) the behavior performance simulation of unmanned vehicles using a SysML state machine diagram.

People living with dementia (PLWD) and their caregivers often face barriers to education, support, and services that can improve their health and quality of life. Information technology (IT) has been suggested as a solution to overcoming such barriers, though the development of evidence-based IT for dementia care is still developing. This project gathered stakeholder (e.g., providers, caregivers) perspectives on the development of a proposed IT solution to support community asset mapping that would allow families to self-assess their dementia-related service needs, educate them about available services, and link them with services they need in their community. This proposed IT would create a dementia resource database that relies on crowdsourced data from community stakeholders as well as relevant data mined from existing sources (e.g., CMS certified nursing home data). As part of the planning process, this project conducted qualitative interviews with providers and caregivers in four metro areas in Alabama and their surrounding rural communities to learn more about the content and features that stakeholders perceive as being most effective for the proposed technology. Stakeholders also discussed their experience of utilizing IT solutions during the COVID-19 pandemic to promote access and continuum of care when barriers to service intensified. Thematic findings provide detail on: 1) motivating factors among stakeholders to contribute crowdsourced data that support community members affected by dementia; 2) potential barriers to implementing IT for dementia support, based on experiences with IT use during COVID-19; and 3) how stakeholders envision IT to better connect community members with needed services.

International audience

Performance and scalability of model transformations are becoming prominent topics in Model-Driven Engineering. In previous work, we introduced LinTra, a platform for executing out-place model transformations in parallel. LinTra is based on the Linda coordination language for archiving concurrency and distribution and is intended to be used as a middleware where high-level model transformation languages (such as ATL and QVT) are compiled. To define modularly the compilation, this paper presents a minimal, yet sufficient, collection of primitive operators that can be composed to (re-)construct any out place, unidirectional model transformation language (MTL). These primitives enable any MTL to be executed in parallel in a transparent way, without altering the original transformation. Universidad de Málaga. Campus de Excelencia Internacional Andalucía Tech.

International audience; Domain-Specific Modeling Languages (DSMLs) are playing an increasingly significant role in software development. By raising the level of abstraction using notations that are representative of a specific domain, DSMLs allow the core essence of a problem to be separated from irrelevant accidental complexities that are typically found at the implementation level in source code. In addition to modeling the functional aspects of a system, a number of non-functional properties (e.g., quality of service constraints, timing requirements) also need to be integrated into models in order to reach a complete specification of a system. This is particularly true for domains that have distributed real-time and embedded needs. Given a base model with functional components, maintaining the non-functional properties that crosscut the base model has become an essential modeling task when using DSMLs. The task of maintaining non-functional properties in DSMLs is traditionally supported by manual model editing or using model transformation languages. However, these approaches are challenging to use for those unfamiliar with the specific details of a modeling transformation language and the underlying metamodel of the domain, which presents a steep learning curve for many users. This paper presents a demonstration-based approach to automate the maintenance of non-functional properties in DSMLs. Instead of writing model transformation rules explicitly, users demonstrate how to apply the non-functional properties by directly editing the concrete model instances and simulating a single case of the maintenance process. By recording a user's operations, an inference engine analyzes the user's intention and generates generic model transformation patterns automatically, which can be refined by users and then reused to automate the same evolution and maintenance task in other models. Using this approach, users are able to automate the maintenance tasks without learning a complex model transformation language. In addition, because the demonstration is performed on model instances, users are isolated from the underlying abstract metamodel definitions. Our demonstration-based approach has been applied to several scenarios, such as auto-scaling and model layout. The specific contribution in this paper is the application of the demonstration-based approach to capture crosscutting concerns representative of aspects at the modeling level. Several examples are presented across multiple modeling languages to demonstrate the benefits of our approach.

International audience

We are pleased to present the proceedings of the Second International Conferenceon Software Language Engineering (SLE 2009). The conference was held in Denver, Colorado (USA) during October 5–6, 2009 and was co-located with the 12th IEEE/ACM International Conference on Model-Driven Engineering Languages and Systems (MODELS 2009) and the 8th ACM International Conference on Generative Programming and Component Engineering (GPCE 2009).The SLE conference series is devoted to a wide range of topics related to artificiallanguages in software engineering. SLE is an international research forum that brings together researchers and practitioners from both industry and academia to expand the frontiers of software language engineering.

Despite the increasing interest in model-driven engineering, there are many open issues that need to be addressed to advance the technology and promote its adoption. This position paper outlines several current limitations of model transformation, with a specific emphasis on model optimization. A primary shortcoming that can be found in many model transformation approaches and tools is the lack of formal semantics to define the meaning of a modeling abstraction. This inadequacy is the source of many problems surrounding the practice of model engineering.

The current synergy of Component-Based Software Engineering (CBSE) and Software Product Line Engineering (SPLE) requires evolution to facilitate Distributed Realtime and Embedded (DRE) system construction. Such evolution is driven by inherent Quality of Service (QoS) characteristics in DRE systems. This paper introduces a QoSdriven SPLE framework (QoSPL) as an analysis and design paradigm for constructing a set of DRE systems as a product line. Leveraging separation of concerns, DRE systems are analyzed and designed by a collection of QoS systemic paths, each of which individually determines how well the service performs along the path and as a whole represents a behavioral view of software architecture. The paradigm reduces construction workload from the problems of tangled functional and QoS requirements and abundant infeasible design alternatives, and offers a less subjective QoS evaluation. The adopted formalisms also facilitate high-confidence DRE product line construction.

In applying Component-Based Software Engineering (CBSE) techniques to the domain of Distributed Real-time and Embedded (DRE) Systems, there are five critical challenges: 1) discovery of relevant components and resources, 2) specification and modeling of components, 3) exploration and elimination of design assembly options, 4) automated generation of heterogeneous component bridges, and 5) validation of context-related embedded systems. To address these challenges, this paper introduces four core techniques to facilitate high-confidence DRE system construction from components: 1) A component and resource discovery technique promotes component searching based on rich and precise descriptions of components and context; 2) A timed colored Petri Net-based modeling toolkit enables design and analysis on DRE systems, as well as reduces unnecessary later work by eliminating infeasible design options; 3) A formal specification language describes all specifications consistently and automatically generates component bridges for seamless system integration; and 4) A grammar-based formalism specifies context behaviors and validates integrated systems using sufficient context-related test cases. The success of these ongoing techniques may not only accelerate the software development pace and reduce unnecessary development cost, but also facilitate high-confidence DRE system construction using different formalisms over the entire software life-cycle.

Our objective was to optimize a protocol using rope devices designed to detect Escherichia coli O157:H7 in feedlot pens by (1) determining if the number of devices influenced the percent of cattle sampled, (2) describing when the cattle contacted the devices, and (3) determining if the time of removal or number of devices influenced the recovery or E. coli O157:H7. Overall, 2948 cattle were observed in 24 commercial feedlot pens, eight pens each in the autumn, winter and summer. Three or seven devices per pen were placed near the water tank and over the feed bunk approximately one hour prior to sunset. Cattle were observed for a 2-hour period to measure (1) the duration of time until they made contact with the devices, and (2) the type of contact they had with the devices. One tail from each of the devices was collected at the end of the 2-hour observation period (ending approximately one hour after sundown) and the other tail was collected the next morning to test for the presence of E. coli O157:H7. Recovery of E. coli O157:H7 was not significantly different using three or seven devices (p>0.10), or if devices were left available overnight (p>0.10). The rate of first contacts did not differ between pens with three or seven devices in any of the 30-minute periods of observation (p>0.50). However, regardless of the number of devices in the pen, the first contact rate was highest in the first 30 minutes and decreased significantly with time (p, The Bovine Practitioner, Vol. 36, No. 1 (2002 February)

We present PrintTalk, a DSL to "program" 3D objects, called "gadgets". PrintTalk also features "topologies", which are predefined spacial arrangements of gadgets. Gadgets are composed by executing a gadget script (possibly consisting of subscripts) that 'draws' the gadget in the 3D scene. However, executing the script also returns a number of constraint variables. These variables can be constrained inside the gadget and can also be bound outside the gadget in order to constrain the produced gadgets after the facts. This is the essence of the gadget composition mechanism of PrintTalk. PrintTalk is implemented in DrRacket. Running a PrintTalk program generates a file that is sent to the 3D printer. We validate PrintTalk qualitatively by comparing the code for complex gadgets with the code needed to print those gadgets in existing languages.

Satisfying real-time requirements in cyber-physical systems is challenging as timing behaviour depends on the application software, the embedded hardware, as well as the execution environment. This challenge is exacerbated as real-world, industrial systems often use unpredictable hardware and software libraries or operating systems with timing hazards and proprietary device drivers. All these issues limit or entirely prevent the application of established real-time analysis techniques. In this paper we propose PReGO, a generative methodology for satisfying real-time requirements in industrial commercial-off-the-shelf (COTS) systems. We report on our experience in applying PReGO to a use-case: A Search and Rescue application running on a fixed-wing drone with COTS components, including an NVIDIA Jetson board and a stock Ubuntu/Linux. We empirically evaluate the impact of each integration step and demonstrate the effectiveness of our methodology in meeting real-time application requirements in terms of deadline misses and energy consumption.

International audience; Within the model-driven engineering field, the concept of "i-DSML" (interpreted Domain Specific Modeling Language) refers to executable models which are interpreted through an engine. While several works discussed the key ingredients of an i-DSML, few of them answered the original question: What is the class of models that are executable by nature and those that are not? This paper attempts to provide some answers by proposing two discriminating criteria: The possibility of defining execution steps and the reification of the behavior of the running system into the executed model. On this basis, we reconsider some well-known DSML and notice a paradoxical situation with UML diagrams. \textcopyright 2016, CEUR-WS. All rights reserved.

As the application of model transformation becomes increasingly commonplace, the focus is shifting from model transformation languages to the model transformations themselves. The properties of model transformations, such as scalability, maintainability and reusability, have become important. Composition of model transformations allows for the creation of smaller, maintainable and reusable transformation definitions that together perform a larger transformation. This paper focuses on composition for two rule-based model transformation languages: the ATLAS Transformation Language (ATL) and the QVT Relations language. We propose a composition technique called module superimposition that allows for extending and overriding rules in transformation modules. We provide executable semantics as well as a concise and scalable implementation of module superimposition based on ATL.

Security decisions are an important part of software architecture design, and thus deserve to be explicitly represented in the design documentation. While UML is the best-known language for creating such documentation, it lacks security specific notations, which makes it difficult to represent the effect of the security decisions. Several security extensions for UML exist in the literature, but they represent security concerns at a lower level of abstraction, or only support a limited subset of security concerns. We propose a new notation, MASC, to model security concerns at the architectural level. It has been designed as an extension of UML, and is based on recurring security concepts that have been distilled from well-known security principles, goals, and patterns. By using our notation, a designer obtains a technique to express security concerns more explicitly in the architectural design documentation. ispartof: pages:36-41 ispartof: 2015 IEEE/ACM 7th International Workshop on Modeling in Software Engineering (MiSE) vol:7 pages:36-41 ispartof: Modelling in Software Engineering (MiSE) location:Florence date:16 May - 17 May 2015 status: published

ispartof: pages:1-6 ispartof: Fifteenth international workshop on aspect-oriented modeling (AOM@MoDELS 2010) pages:1-6 ispartof: International conference on model driven engineering languages and systems (MODELS 2010) location:Oslo, Norway date:3 Oct - 8 Oct 2010 status: published

In this paper we present a generic, mirror-based debugging architecture that supports runtime visibility and traceability of aspect oriented (AO) software systems. Runtime visibility supports inspection of an executing AO-system in terms of AO programming abstractions and code artifacts such as (dynamic) aspects, advices, pointcuts, aspect instances and advice applications. Runtime traceability supports inspection of the stack to identify advices that could have been executed, that are being executed, or that may be executed later. Additionally, traceability supports identification and inspection of the pointcut that causes a specific advice. We have created a mirror based architecture that offers introspection support including an aspect-aware breakpoint model for AOP-related runtime events. We introduce the concept of hook frames to trace joinpoints and their advices on the stack. We validate the genericity of our architecture in two instantiations - JBoss AOP and AspectJ/ABC - and evaluate both instantiations by applying concrete debugging scenarios. ispartof: pages:173-184 ispartof: Proceedings of the 8th ACM international conference on Aspect-oriented software development pages:173-184 ispartof: AOSD location:Charlottesville date:2 Mar - 6 Mar 2009 status: published

The benefits of defining explicit pointcut interfaces in aspect-oriented applications have been advocated by many. A pointcut interface exposes a set of crosscutting abstract behaviours (as named pointcut signatures) that multiple aspects in the application can use. In accordance with the dependency inversion and stable dependencies principles, a pointcut interface should expose only stable abstractions in order to maximally promote its reuse across a family of applications. In this paper, we propose a domain-driven architecture method for designing such stable pointcut interfaces. The method employs systematic reengineering of use case models to discover stable abstractions that are anchored in the domain model of the application. During architecture design, these stable domain abstractions are mapped to pointcut interfaces. As part of this mapping activity, the architecture is constrained to ensure that the pointcut interfaces can be implemented correctly. We have applied this method in two applications, where we validate that pointcut interfaces can be reused for implementing the composition logic of different aspects without requiring modification to their pointcut signatures. Moreover, the method consistently yields pointcut interface hierarchies. ispartof: pages:75-86 ispartof: Proceedings of the International Conference on Aspect-Oriented Software Development (AOSD 2009) pages:75-86 ispartof: Internation Conference on Aspect-Oriented Software Developement (AOSD) location:Charlottesville, Virginia, USA date:2 Mar - 6 Mar 2009 status: published

Model transformation languages have matured to a point where people have started experimenting with model transformation definitions themselves in addition to the language they are written in. In addition to the transformation language properties, the properties of model transformation definitions themselves become important, such as scalability, maintainability and reusability. Composition of model transformations allows for the creation of smaller, maintainable and reusable model transformation definitions that can scale up to a larger model transformation. There are two kinds of composition for model transformations. External composition deals with chaining separate model transformations together by passing models from one transformation to another. Internal composition composes two model transformation definitions into one new model transformation, which typically requires knowledge of the transformation language. This paper focuses on internal composition for two rule-based model transformation languages. One is the ATLAS Transformation Language, which serves as our implementation vehicle. The other is the QVT Relations language, which is a standard transformation language for MOF. We propose a composition technique called module superimposition. We discuss how module superimposition interacts with other composition techniques in ATL, such as helpers, called rules and rule inheritance. Together, these techniques allow for powerful composition of entire transformation modules as well as individual transformation rules. By applying superimposition to QVT Relations, we demonstrate that our composition technique is relevant outside the ATL language as well.

ispartof: pages:1-10 ispartof: Eleventh international workshop on aspect-oriented modeling (AOM@MODELS 2007) pages:1-10 ispartof: International conference on model driven engineering languages and systems (MODELS 2007) location:Nashville, Tennessee, USA date:30 Sep - 5 Oct 2007 status: published

Lactobacilli are important members of the microbiota in swine. These bacteria have the ability to inhibit growth of pathogens and modulate the microenvironment of the gastrointestinal tract. The thesis objectives were to design a 16S rRNA 'Lactobacillus'-specific oligonucleotide probe that could be converted into a peptide-nucleic-acid (PNA) probe, and then to evaluate this probe using 'Lactobacillus' spp. and ' in vivo.' Examination by microbial fluorescence 'in situ' hybridization demonstrated that G'Lac'385 has superior specificity, sensitivity and efficiency in detection of 'Lactobacillus' organisms. G'Lac'385 was also examined 'in vivo,' and this research suggests that feces should not be used as a reliable indicator for 'Lactobacillus' populations present in swine ileum. Also, these results indicate that population changes in 'Lactobacillus ' are host-dependant. The ability of G'Lac'385 to rapidly detect, identify and enumerate 'Lactobacillus' populations in mixed samples is a valuable tool that can be used for quantification of Lactobacilli in future research.