Issues and Challenges in Building a Framework for Reactive Agent Systems

The agent-oriented approach has emerged as a new and powerful paradigm in modern software engineering. This paper analyzes the reactive agent model, exhibiting innovative characteristics of autonomy, goal-direction, reactive capability, concurrency, and interactivity. Contrary to object depictions of attribute and method signatures, reactive agents are described in terms of their behavior. Due to the complex nature inherent to reactive agent behavior, the need for formal specification and design integrity becomes essential. Descartes is an executable specification language, which has historically been applied to provide such design assurance. This paper describes a formal approach to deriving a reactive agent software design represented in the Agent Unified Modeling Language (AUML). The objective is accomplished through extension of the Descartes specification language and application of a transformation into design representation. The addition serves as a method of providing a guarantee of design reliability by way of gap reduction between requirements analysis and design

Developing software systems that are complicated and critical gives challenges to software engineers and the software industry. Intelligent software agent design is one such application domain that imposes challenges. The application of formal methods in software engineering, specifically with executable software specification languages, can involve much learning among the users of the system. Although executable software specifications tend to be advantageous over the traditional software specification process, the passive growth inside industry remains open for research efforts to come up with the hidden myths. The application of formal methods during system development of intelligent software agents makes the design of the product reliable. This paper describes an approach that combines an extension to the widely used Unified Modeling Language (UML) for design with an executable specification language. Also, the paper describes an approach that transforms agent oriented specifications written using the extended Descartes specification language into a high level design representation using Agent UML (AUML).

The Robot Operating System (ROS) is a framework for building robust software for complex robot systems in several domains. The Navigation Stack stands out among the different libraries available in ROS, providing a set of components that can be reused to build robots with autonomous navigation capabilities. This library is a critical component, as navigation failures could have catastrophic consequences for applications like self-driving cars where safety is crucial.Here we devise a general methodology for verifying this kind of complex systems by specifying them in different executable specification languages with verification support and validating the equivalence between the specifications and the original system using differential testing techniques. The complex system can then be indirectly analyzed using the verification tools of the specification languages like model checking, semi-automated functional verification based on Hoare logic, and other formal techniques. In this paper we apply this verification methodology to the NavFn planner, which is the main planner component of the Navigation Stack of ROS, using Maude and Dafny as specification languages. We have formally proved several desirable properties of this planner algorithm like the absence of obstacles in the planned path. Moreover, we have found counterexamples for other concerns like the optimality of the path cost.

The growing reliance on commercial-off-the-shelf (COTS) components for large-scale projects has introduced a new paradigm in software engineering, requiring the design of new software development methods and business processes. Large-scale component reuse leads to savings in development resources, but increases the system’s vulnerability to risks arising from third-party development, as well as integration difficulties, performance constraints, and incompatibility of components from multiple vendors. The framework discussed in this chapter aims to alleviate quality concerns for COTS-based systems by using software metrics to accurately quantify factors contributing to the overall quality of a component-based system, guiding quality and risk management by identifying and eliminating sources of risk. Tradeoffs between cost and quality in a component-based system are discussed, as well as analytical techniques and formal models for cost and quality decisions.

Formal methods are a usual means to avoid errors or bugs in the development, adjustment and maintenance of both software and knowledge bases. This chapter provides a formal method to refine a knowledge base based on insides about its correctness derived from its use in practice. The objective of this refinement technique is to overcome particular invalidities revealed by the application of a case-oriented validation technology, i.e. it is some kind of “learning by examples”. Approaches from AI or Data Mining to solve such problems are often not useful for a system refinement that aims at is an appropriate modeling of the domain knowledge in way humans would express that, too. Moreover, they often lead to a knowledge base which is difficult to interpret, because it is too far from a natural way to express domain knowledge. The refinement process presented here is characterized by (1) using human expertise that also is a product of the validation technique and (2) keeping as much as possible of the original humanmade knowledge base. At least the second principle is pretty much adopted from Software Engineering. This chapter provides a brief introduction to AI rule base refinement approaches so far as well as an introduction to a validation and refinement framework for rulebased systems. It also states some basic principles for system refinement, which are adopted from Software Engineering. The next section introduces a refinement approach based on these principles. Moreover, it considers this approach from the perspective of the principles. Finally, some more general conclusions for the development, employment, and refinement of complex systems are drawn. The developed technology covers five steps: (1) test case generation, (2) test case experimentation, (3) evaluation, (4) validity assessment, and (5) system refinement. These steps can be performed iteratively, where the process can be conducted again after the improvements have been made.

Design management systems have been developed and researched for traditional product and service industries. For interaction design little research has been performed on design management. The objective of this paper is to describe aspects of and provisions for industrial interaction design that influence approaches to design management within system and software development. We discuss whether there are specific conditions for design management of interaction design within the software and system development industries. The research is based on three short case studies from industrial software development. We identify some of these specific conditions; the difference between a usage and a product perspective, the design tools and practices, and the modularized and distributed processes. These issues point towards challenges facing design management within the software and system development context, as well as the need for interaction design to clarify its position as a strategic resource in software companies. The conclusions point towards the need for continued research on strategic possibilities and alternatives to organize and manage design work in software and system development.

A “software crisis,” identified more than twenty years ago, still exists today. This article discusses how that embarrassing predicament may now be relieved using a living systems model (LSM). The LSM with its critical subsystems and other crucial key concepts can form a very powerful conceptual tool in the software engineering process of specifying and designing computer programs. The proposed method can be seen as an extension of the object-oriented approaches currently in use. The LSM also can form a contextual ramification for the supported system, the programming system and the programmed system, with their obvious interdependencies.

The Microservice Architecture Style (MSA) has emerged as a significant computing paradigm in software engineering, with companies increasingly restructuring their monolithic systems to enhance digital performance and competitiveness. However, the migration process, particularly the microservice identification phase, presents complex challenges that require careful consideration. This study aimed to provide developers and researchers with a practical roadmap for microservice identification during legacy system migration while highlighting crucial migration steps and research requirements. Through a systematic mapping study following Kitchenham and Petersen’s guidelines, we analyzed various microservice identification approaches and developed a middleweight ontology that can be queried for key inputs, data modeling, identification algorithms, and performance evaluation metrics. Our research makes several significant contributions: a comprehensive analysis of existing identification methodologies, a multi-dimensional framework for categorizing and evaluating approaches, an examination of current research trajectories and literature gaps, an ontological framework specifically designed for microservice identification, and an outline of pressing challenges and future research directions. The study concluded that microservice identification remains a significant barrier in system migration efforts, highlighting the need for more research focused on developing effective identification techniques that consider various aspects, including roles and dependencies within a microservice architecture. This comprehensive analysis provides valuable insights for professionals and researchers working on microservice migration projects.

In this paper,I first review the seminal work by Thomas Kuhn — The Structure of Scientific Revolutions — and elaborate my view on paradigm shifts in software engineering research and practice as it turns 50 years old in 2018. I then examine major undertakings of the computing profession since early days of modern computing, especially those done by the software engineering community as a whole. I also enumerate anomalies and crises that occurred at various stages, and the attempts to provide solutions by the software engineering professionals in the past five decades. After providing such a background, I direct readers attention toward emerging anomalies in software engineering, at a severity level that is causing another software engineering crisis, and suggest a set of criteria for feasible solutions. The main theme of this paper is to advocate that situation analytics, equipped with necessary definitions of essential concepts including situation and intention as parts of a new computational framework, can serve as the foundation for a new software engineering paradigm named the Situation-Centric Paradigm. In this framework, situation is considered a new abstraction for computing and is clearly differentiated from the widely accepted existing abstractions, namely function and object. I argue that the software engineering professionals will inevitably move into this new paradigm, willingly or unwillingly, to empower Human-Embedded Computing (HEC) and End-User Embedded Computing (EUEC), much more than what they have done with traditional human-centered or user-centric computing altogether. In the end, I speculate that an ultimate agile method may be on the rise, and challenge readers to contemplate “what if" hundreds of thousands “end-user developers" emerge into the scene where the boundaries between end users and developers become much more blurred.

\n Contains fulltext :\n 158152.pdf (Publisher’s version ) (Open Access)\n

Reactive synthesis is an automated procedure to obtain a\ncorrect-by-construction reactive system from a given specification. GR(1) is a\nwell-known fragment of linear temporal logic (LTL) where synthesis is possible\nusing a polynomial symbolic algorithm. We conducted a case study to learn about\nthe challenges that software engineers may face when using GR(1) synthesis for\nthe development of a reactive robotic system. In the case study we developed\ntwo variants of a forklift controller, deployed on a Lego robot. The case study\nemploys LTL specification patterns as an extension of the GR(1) specification\nlanguage, an examination of two specification variants for execution\nscheduling, traceability from the synthesized controller to constraints in the\nspecification, and generated counter strategies to support understanding\nreasons for unrealizability. We present the specifications we developed, our\nobservations, and challenges faced during the case study.\n

As software becomes more and more entrenched in everyday life in today’s society, security looms large as an unsolved problem. Despite advances in security mecha-nisms and technologies, most software systems in the world remain precarious and vulnerable. There is now widespread recognition that security cannot be achieved by technology alone. All software systems are ultimately embedded in some human social environment. The effectiveness of the system depends very much on the forces in that environment. Yet there are few systematic techniques for treating the social context of security together with technical system design in an integral way. In this chapter, we argue that a social ontology at the core of a requirements engineering process can be the basis for integrating security into a requirements driven software engineering process. We describe the i* agent-oriented modelling framework and show how it can be used to model and reason about security concerns and responses. A smart card example is used to illustrate. Future directions for a social paradigm for security and software engineering are discussed.

Software Product Line Engineering (SPLE) is a software engineering paradigm that focuses on reuse and variability. Although feature-oriented programming (FOP) can implement software product line efficiently, we still need a method to generate and prove correctness of all product variants more efficiently and automatically. In this context, we propose to manipulate feature modules which contain three kinds of artifacts: specification, code and correctness proof. We depict a methodology and a platform that help the user to automatically produce correct-by-construction product variants from the related feature modules. As a first step of this project, we begin by proposing a language, GFML, allowing the developer to write such feature modules. This language is designed so that the artifacts can be easily reused and composed. GFML files contain the different artifacts mentioned above.The idea is to compile them into FoCaLiZe, a language for specification, implementation and formal proof with some object-oriented flavor. In this paper, we define and illustrate this language. We also introduce a way to compose the feature modules on some examples.

The existing software engineering seldom considers software usability, and human-computer interaction (HCI) techniques which can improve the software usability cannot guarantee development efficiency. Recently, more and more stakeholders and users begin to regard the usability as an important software requirement. In order to bring respective advantages of software engineering and HCI techniques into full play to improve software usability and development efficiency, the paper presents user model driven software development, which integrates HCI techniques into software development method by eliciting user model under the participation of user, HCI designer and software engineer. Applications show that the method can be effectively applied to small software development team, and can raise software usability and development efficiency.

An Active Network Management system comprises a large number of different technical systems that interact in several ways to pursue local objectives. The Smart Grid Architecture Model was developed for the description of the coupling of these technical systems and scenarios within an Active Network Management system. In this paper, this modelling paradigm is applied for the requirements engineering and a uniform description of a cross-sectoral Active Network Management system. Essential requirements are shown and described in relation to the two upper layers of the Smart Grid Architecture Model. Based on the requirements engineering results, the implementation of a multi agent system is proposed. For the development of this multi agent system, a new software engineering paradigm is applied. Finally, the functionality use-case developed cross-sectoral Active Network system are described, which will be investigated in a later field test.