A picture is worth a thousand words. Non-Functional Requirements (NFRs), such as security and usability, are modeled using Softgoal Interdependency Graphs (SIGs) to capture potential conflicts and synergies. However, the practice of NFR modeling remains limited, partly due to unfamiliarity with modeling languages like SIG and insufficient understanding of relevant NFRs. Large Language Models (LLMs) show some knowledge of NFRs and SIG concepts, such as goal decomposition and operationalization, but often lack precise knowledge of formal SIG syntax. We introduce SIG-GPT, a GPT-4-based LLM augmented with SIG knowledge using text-based grammar supplied and Retrieval Augmented Generation (RAG). RAG enhancs LLM responses by retrieving relevant external knowledge, while the grammar enforces correct syntax, guiding the LLM to generate SIGs align with formal notation. To help practitioners better understand SIG modeling, reduce time and effort, and enhance NFR proficiency, we apply textual grammar to SIG-GPT, ensuring it is ready for seamless integration with visual modeling tools like RE- Tool, enabling the LLM to generate correct SIG structures without requiring a large dataset of SIG examples. Results show that SIG-GPT with grammar and RAG achieves 100% syntactic accuracy, 95% semantic accuracy, and 98% cohesion (CCR) while aligning with Bloom's Taxonomy to enhance structured reasoning in SIG modeling.

Nonfunctional requirements (NFRs), such as security and usability, address how well a software system does its intended functions.Automatic NFR classification using machine learning (ML) has been proposed to address the potential problem of faulty manual classification of NFRs.In order for ML to be effective, however, we need large, relevant datasets for training.Training data shortage has been identified as a limiting factor for these approaches.Even when available, procuring proprietary NFR data is challenging and time-consuming.In this paper, we propose a process to generate synthetic labeled NFR datasets using GPT-4o, a large language model (LLM), to alleviate the data shortage issue.This process consists of a set of prompt templates, iterative contextualization of definition, and NFR generation by class.We produced 2 new labeled NFR datasets, one from synthetic generation and the other from real documents for validation.To determine both the strengths and weaknesses of the synthetic dataset, we used it to train ML models using 3 different algorithms for the multi-class NFR classification task.Although limited, we feel our experimental results show that synthetic data as well as augmented data perform better than just real data alone.

Non-functional requirements (NFRs), such as usability, safety, security, and the like, describe how well the software system should do what it’s intended to do functionally, and, as such, should be addressed well. However, addressing NFRs well is not easy. In this talk, I will explore using Generative AI for facilitating representation and reasoning with NFRs, at a time when interest in utilizing Machine Leaning/Generative AI seems to be spreading like a wildfire in many industries and research areas. Unsurprisingly, software engineering more broadly, and requirements engineering more specifically, seems no exception to this. After discussing a problem-driven, ontology-based approach to question (prompt) engineering, I will briefly describe some critical challenges going forward at the end.

We offer a retrospective on a paper published in the IEEETransactions on Software Engineeringin 1992, hereafterthe NFR paper, that recently won a Most Influential Paper award. We first present the main contributions of the NFR paper, followed by subsequent work that extended and improved these contributions and discuss their impact. We conclude with retrospective remarks on the strengths and weaknesses of the NFR paper proposal.

3D models (or assets) that are present in many of modern software applications are first modeled by graphic designers using dedicated computer graphic tools and then integrated into such software applications or apps by software developers. This simple workflow/procedure requires developers to have a basic grounding in computer graphics, since 3D engines, libraries and third-party software are needed for this kind of integrations. Oftentimes, 3D designers are also required to customize or produce versions of a 3D model and thus, they must re-model all the assets before they are returned back to the developers for integration into the applications. This procedure also occurs whenever a modification or customization is requested. One possible significant improvement to this traditional, poorly automated workflow is to use services-oriented technology and features servitization to carry out the customization of 3D assets on-demand. In this article, we introduce$ \mu $S3D, an open-source microservices-based platform designed to support features relating to the customization of 3D models.$ \mu $S3D not only enables 3D assets to be customized without the need for computer graphic tools or designers, but also allows 3D models to be visualized through web technologies (e.g., HTML, Javascript and web component to visualize and interact with 3D models), thereby avoiding the development of computer graphics libraries or components in final software products. The article describes the elements that$ \mu $S3D comprises, explains how it works and presents a series of load tests to compare the performance (time consumption, CPU and memory utilization) of$ \mu $S3D when implemented and deployed as a microservices platform against a monolithic-based implementation, showing similar results with a low number of users (and requests) but reducing, on average, 64.32% the response time in the microservice-based implementation for a large number of users; reducing CPU utilization on microservice-based implementation and remaining the memory usage more or less constant in both implementations.

Manufacturing medical devices is a costly and com-plex operation. The Original Equipment Manufacturer (OEM) must enforce United States Food and Drug Administration (FDA) design control regulations during the entire medical device manufacturing life cycle. To lower the costs, the OEMs often out-sources device manufacturing to a Contract Manufacturer (CM). Usually, the OEMs and CMs use incompatible software tools to manage requirements, design documents, and manufacturing data, leading to information silos that makes business process orchestration, and maintaining traceability across documents mandated by FDA challenging. To our best knowledge, existing commercial software vendors still need to address these issues adequately. This paper presents a blockchain-based framework for implementing FDA design control regulations by achieving cross-organizational reviews, document traceability, and tamper-resistant storage and verification of records while allowing the OEM and CM to continue using incompatible software tools. The framework provides an FDA design control ontology, smart contract data model, architecture and a prototype to validate the framework and its applicability using Hyperledger Fabric. Our experimentation shows the framework achieved it's goals with satisfactory performance.

If risks are not identified, they are unlikely to be addressed, possibly resulting in undesirable consequences, such as fatal accidents or even loss of human lives.Furthermore, risks should be considered not only in terms of system behavior but also events occurring in the system environment -i.e., in a collaborative setting in which the system and its environment work together towards certain goals the system is intended to help achieve.In this paper, we present a goal-oriented risk analysis framework, Murphy+G, in which non-functional requirements (hereafter, NFRs) are treated as softgoals to be achieved and systematically addressed in terms of both the system and its environment during requirements engineering, by adopting what is called the Reference Model.A study of a smartphone app, Theia, which is intended to help blind people navigate indoors, is used for the purpose of both illustration and experimentation.In this study, NFRs (e.g., safety, reliability, timeliness, etc.) are treated as softgoals, and risks (e.g., fall down, injury, etc.) are identified, along with risk-mitigation strategies for both the system and its environment, with the help of an activity-oriented ontology.To see both the strengths and weaknesses of Murphy+G, a systematic methodology for risk analysis for collaborative systems, a controlled experiment has been carried out, in terms of three different versions of Theia implementations.Feedback from students show improvements on the accuracy of the risk analysis and the risk mitigation strategies devised, as well as enhanced users' experience with respect to increased confidence in navigating indoors, in a safe, timely, and reliable manner.

A risk is an undesirable event that can result in mishaps if not identified early on during requirements engineering adequately.However, identifying risks can be challenging, and requirements engineers may not always be aware if risks are ignored.In this paper, we present Murphy -a framework for performing risk analysis.Murphy adopts the Reference Model, in which requirements are supposed to be met not by the projected software system behavior alone but through collaboration between the system and events occurring in its environment, hence the term Collaborative System.Murphy provides risk analysis facilities that include an activity-oriented ontology for carrying out risk analysis by systematically identifying risky activities in the system and in the environment, thereby obtaining a Risk Analysis Graph (RAG) and towards devising risk mitigation strategies later.In order to see both the strengths and weaknesses of Murphy, we experimented on developing a smartphone app involving a group of Ph.D. and senior-level graduate students -one group using Murphy and the other not using Murphy.Our observation, we feel, shows that the risks identified by the group using Murphy were able to identify more critical risks and those risks were comprehensive and relevant as.well.The results also showed that incorporating risk mitigation strategies for the risks identified can indeed help avoid them to some extent.

Risk, a potential occurrence of some undesirable event, can be dangerous if not adequately identified and dealt with early on during software development.However, identifying risks can be difficult, hence oftentimes resulting in a particular software system that is unable to address risks, especially critical ones adequately.This paper proposes an ontology-based framework for performing risk analysis with the Augmented Reference Model -The Reference Model augmented with risk analysis.The Reference Model emphasizes that the user requirements are met through the collaboration between the system and the events occurring in its environment -i.e., not by the system alone, hence the term "collaborative system."We also offer an activity-oriented ontology to carry out risk analysis by identifying risks from negating the events in the environment and system. Such negations of the requirements, specifications, and domain events generate a graph-like representation, called Risk Analysis Graph (RAG), to help perform risk analysis.To validate our framework, we have performed two experiments using questionnaires to identify risks and use the risk analysis tool to generate RAG for performing risk analysis.We feel that at least these experiments show that RAG helps identify risks -especially the critical and uncommon ones that we would not have thought of.

Abstract A large volume of highly diverse and real‐time data provided by social network sites has revolutionized several data analytical sciences such as stock exchange fluctuation prediction, sentiment analysis, and political affiliations prediction. From a software engineering viewpoint, social network sites have produced an unprecedented opportunity for software development organizations to monitor the opinion of the large population of users of their systems. The extracted data from social network sites can be used to extract information about newly launched systems, and it enable software development organizations to obtain rapid technical and social feedback about their systems. This paper presents on a systematic literature review of the published research articles on how requirements engineering (RE) activities are conducted using social network sites, elaborated in studies published between 2011 and 2019. From the resulting studies, we extracted data to answer our four questions related to social network site (SNS)‐based RE approaches focusing on requirements elicitation, prioritization, and negotiation activities. Thirty‐one relevant studies were identified and analyzed to answer our research questions. Among 31 studies, 62% of the studies reportedly support requirements elicitation activity, and 14% of the studies reportedly support requirements elicitation, prioritization, and negotiation activities. Ten percent studies were about requirements elicitation and prioritization activities, 7% of the studies support both requirements elicitation and negotiation activities, and prioritization activity was supported by 7% of the studies. It was also observed that 58% of the selected studies adopted semi‐automatic approaches to conduct RE activities while 21% of the selected studies proposed automatic tools, and 21% of the selected studies adopted manual approaches to conduct RE activities. The outcomes of this systematic literature review indicate that social network sites can be a major source that can be used successfully to extract and identify user requirements. Moreover, this systematic literature review also presents implications of this study for practitioners and researchers including challenges, unresolved issues, and future research directions.

Blockchain is intended to help enhance the trustworthiness of data and transactions, by chaining and distributing blocks of the same data so that they may become more transparent, traceable, and immutable. With such a great potential, blockchain is increasingly being explored in many applications, especially in the presence of (potential) dis-/mis-/un-trust among organizations and individuals, well beyond its original use, namely, for bitcoin. However, an ad hoc approach to adopting blockchain may lead to not better, but worse, situations and results, and with severe disappointments. In this talk, I will describe Fides - a framework for systematically utilizing blockchain towards enhancing business processes with trustworthiness. Fides takes a goal-oriented, software engineering approach, in which trust-related concerns are explicitly represented as (soft)goals to be achieved, problems for achieving the goals are diagnosed, and then alternatives are explored in terms of business processes for eliminating or alleviating the problems, while at the same time achieving the goals. Finally, a selection is made among the alternatives that best utilize blockchain. In this approach, business processes are modelled, rules are formulated at the requirements level for beneficially transitioning from as-is to to-be, and transformed into smart contracts. At the end, I will describe a couple of applications of Fides, for an initial assessment of its strengths and weaknesses.

Software effort estimation is a key factor for software development project success. Case-based reasoning (CBR), as a viable alternative to analogy methods, has often been used as a reference to calculate effort estimation. Albeit its conceptual simplicity, however, CBR-based effort estimation seems difficult and complex in reality, especially when enhancement on the estimate precision is highly desirable. For an effective and fast estimation, we present in this paper an innovative tool, automated-SEE (software effort estimation), for estimating software development effort using improved CBR. This tool enables the consideration of a comprehensive set of different types of requirements, including both functional requirements (FRs) and non-functional requirements (NFRs), and domain properties (DPs). Application of this tool to 36 (students') projects shows that the resulting software effort estimation is highly reliable.

A business process is a collection of activities to create more business values and its continuous improvement aligned with business goals is essential to survive in fast changing business environment. However, it is quite challenging to find out whether a change of business processes positively affects business goals or not, if there are problems in the changing, what the reasons of the problems are, what solutions exist for the problems and which solutions should be selected. Big data analytics along with a goal-orientation which helps find out insights from a large volume of data in a goal concept opens up a new way for an effective business process reengineering. In this paper, we suggest a novel modeling framework which consists of a conceptual modeling language, a process and a tool for effective business processes reengineering using big data analytics and a goal-oriented approach. The modeling language defines important concepts for business process reengineering with metamodels and shows the concepts with complementary views: Business Goal-Process-Big Analytics Alignment View, Transformational Insight View and Big Analytics Query View. Analyzers hypothesize problems and solutions of business processes by using the modeling language, and the problems and solutions will be validated by the results of Big Analytics Queries which supports not only standard SQL operation, but also analytics operation such as prediction. The queries are run in an execution engine of our tool on top of Spark which is one of big data processing frameworks. In a goal-oriented spirit, all concepts not only business goals and business processes, but also big analytics queries are considered as goals, and alternatives are explored and selections are made among the alternatives using trade-off analysis. To illustrate and validate our approach, we use an automobile logistics example, then compare previous work.

Requirements traceability helps to ensure that a re- quirements specification is aligned with the intended stakehold- ers' needs. Such alignment should involve the consideration of why such needs arise, in terms of what problems the stakeholders are faced with, and what kinds of software system may help alle- viate or eliminate the problems. However, little work can be found on requirements traceability that explicitly considers the problems. In this paper, we propose an problem-aware frame- work for establishing requirements traceability, in the context of goal-oriented requirements engineering, which explicitly models problems and their root causes, together with other important ontological concepts, stakeholders' goals, and both functional and non-functional requirements as a solution, and issues. In this framework, ontological concepts are partitioned into layers, re- flecting which traceability links are classified into intra- and in- ter-traceabilities leading to several kinds of links. Additionally, undesirable consequences of inappropriate traceabilities are also categorized. A case study shows some key benefits of the frame- work.

Summary form only given. Big data promises to lead to better decisions, which can bring greater operational efficiency, productivity, reduced cost and risk, and the like to a variety of domains. But is the use of big data always going to be beneficial, and if so how? In answering this question, I will first survey research in big data from a requirements engineerin g perspective. Afterwards, I will describe a goal-oriented approach - which adopts but goes beyond an object-oriented approach, to beneficially using big data. This approach is intended to rationally "connect the dots", from stakeholders' problems and needs, business key performance indices, important insights through analytics for both AS-IS and TO-BE, machine learning techniques, SQL/NoSQL database queries, etc. I will talk about how this approach can aid business decision making in general and more specifically in business process reengineering, possibly with a tool support. At the end, I will outline some of the software engineering challenges in more beneficially using big data.

Patterns aid in the development of software for micro-businesses. However, capturing recurring concepts in good representations for the purpose of requirements engineering is challenging. Such representations need to be intuitive enough so that non-technical people such as micro-business owners can understand them. At the same time, the representations have to be technical enough so that software developers can use them for software design and development. In this paper, we propose a requirements-based approach for representing micro-business patterns. We describe pattern emergence from observation and analysis. We list down and specify both the functional and nonfunctional requirements of the micro-business in a table and then represent the workflows using diagrams. We use a combination of a business process modeling notation, softgoal interdependency graphs, and our own customized symbols. Four real-world micro-business cases are discussed in the paper in order to see both the strengths and weaknesses of our approach.

Requirements engineers need to understand and model different aspects of organizations and systems under construction, and may need to use different modeling notations. However, most modeling tools support only one (or at most a few notations), hindering requirements engineers from using the most appropriate notations for the particular modeling task. The RE-Tools is an open-source toolkit implemented using a UML Profile for StarUML, an open-source UML modeling tool. The toolkit supports many leading requirements modeling notations, including the NFR Framework, the i* Framework, KAOS, Problem Frames, and UML. Each of these notations may be used for modeling independent corresponding diagrams or together with non-functional requirements (NFRs). The toolkit also supports the original qualitative reasoning of the NFR Framework and augments with a quantitative one.

In real world, most business processes are subject to time constraints. Equally important as the execution of a process is the time in which it is to be performed. A time constrained business process can be defined as a process whose correct behavior depends not only on the results obtained, but also on the time it is carried out. UML has become an important tool for model-driven software development, perhaps partly thanks to its visually oriented modeling concepts, and it is increasingly being used in business process modeling too. In this paper, we extend UML 2.0 Activity Diagrams with time annotations and new modelling constructs inspired of the Timed CSP language. Furthermore, in order to overcome the lack of formal semantics that these diagrams suffer from, we introduce a set of mapping rules to derive formal specifications in terms of Timed CSP processes from models in the extended Activity Diagrams being proposed. Timed CSP has several features that make it well suited to give a formal semantics for extended Activity Diagrams (e.g., compositionality, well defined denotational and operational semantics, etc.). The proposed mapping rules enable checking whether the model described in an Activity Diagram satisfies such properties as timeliness, deadlock freeness, liveness, etc. In order to show the applicability of our approach, we present a case study from a manufacturing domain.

Non-functional requirements (NFRs), such as security and cost, are generally subjective and oftentimes synergistic or conflicting with each other. Properly dealing with such NFRs requires a large body of knowledge – goals to be achieved, problems or obstacles to be avoided, alternative solutions to mitigate the problems, and the best compromising alternative solution to be selected. However, few patterns exist for dealing with these kinds of knowledge of NFRs. In this paper, we present four kinds of NFR patterns for capturing and reusing knowledge of NFRs – objective pattern, problem pattern, alternatives pattern and selection pattern. NFR patterns may be visually represented, and organized by rules of specialization to create more specific patterns, of composition to build larger patterns, and of instantiation to create new patterns using existing patterns as templates. We have applied the NFR pattern approach to the TJX incident, one of the largest credit card theft in history, as a realistic case study.

Traceability between hazards and countermeasures is important for hazard analysis to give confidence and help justify whether relevant hazards have been considered and sufficiently mitigated. However, use case modeling, the current de facto standard technique for requirements elicitation lacks negative modeling constructs for representing hazards. This paper presents a case study to apply a goal-oriented method for car security related hazard analysis where hazards are represented as operationalizations with negative contribution toward system non-functional requirements (NFRs). In turn, countermeasures are represented as operationalizations with negative contribution toward the respective hazards to negate their negative effect on the NFRs. The study finds that using the goal-oriented approach is most suitable for risk-driven applications, but also compatible and complementary to other applications.

Enterprise Architectures (EA’s) usually capture the information technology architecture of the organization including hardware, software, and networking standardizations, if any, that serves as the basis for all information systems developed within an organization. Usually EA’s are closely aligned to the Strategic Enterprise Plan of the organization. Any information system developed within the organization is derived, on the other hand, from the Strategic Information Systems Plan of the organization. The initial stages of developing an information system, after approval by the executive sponsors, include the scope definition, problem analysis and the requirements analysis phases. It is during the requirements analysis phase that the requirements of the new system are elicited from the stakeholders and analyzed – the analysis includes, among other aspects, the development of candidate system architectures (SA) that considers different ways of allocating the requirements between hardware, software and the network. One way of selecting the optimal architecture among the candidate system architectures is to determine the compliance of the architectures with the enterprise architecture. In this paper we provide a framework, called the Propagatory Framework, for establishing the traceability between SA and the EA that is based on the NFR Approach where NFR stands for Non-Functional Requirement. We demonstrate the practicality of the Propagatory framework by applying it to determine the traceability of the system architectures for a Home Appliance Control System (HACS).

This workshop summary presents an overview of the one-day International Workshop on Models and Processes for the Evaluation of off-the-shelf Components (MPEC'05), held in conjunction with the 27th International Conference on Software Engineering (ICSE'05). Details about MPEC'05 may be found at http://www.lsi.upc.edu/events/mpec/.

We have been maintaining the Engineering Department's Web site at Hofstra University for the past five years and our experience has been a mixed one: on the one hand it usually takes a few days to make even minor modifications to the Web site while on the other, the chain of checks and balances ensures that the updates work and the accuracy of the new information is high. We thought it is an interesting and useful exercise to analyze and qualitatively evaluate the Web site maintenance policy at Hofstra compared to other universities so that this information helps all concerned stakeholders to make modifications to the policy, if needed. We used the NFR framework for the analysis and evaluation, and compared the closely related NFRs (or non-functional requirements) of maintainability and cost (both, time and money costs), for the three different Web site maintenance policies used in the academia including that of Hofstra Engineering Department, and concluded that while there are tradeoffs involved, small changes in Hofstra's policies could significantly increase the maintainability of the Engineering Department Web site.

In order for a software system to be of value, it should meet both functional requirements (FRs) and non-functional requirements (NFRs). Concerning FRs, UML has been used as the de facto object-oriented analysis and design notation. Concerning NFRs, the NFR framework extends, and complements, UML, by treating NFRs as potentially conflicting or synergistic softgoals to be achieved, thereby allowing for the consideration of alternatives and analysis of trade-offs among the alternatives. Albeit the complementary nature of the two, UML and the NFR framework offer two different notations -syntactically, semantically and visually, which makes it difficult to produce requirements models that integrate both FRs and NFRs. In this paper, we propose an integrated modeling language by extending UML with the NFR framework using the standard extension mechanism called UML profile where we define a metamodel to represent the concepts in the NFR framework and identify the extension points for integrating the two notations. We also show how CASE tools may use this profile in building an integrated requirements model based on a model of the well known London ambulance case study.

Retrofitting security requirement into an existing system tends to result in less wanted qualities. So, it is a preferred practice to design with security in mind right from the beginning of the development process. An NFR framework has been established to incorporate non-functional requirements (NFRs) (L. Chung et al., 2000) that are crucial to secure system design into the development process. In this paper, we propose a methodology that utilizes the NFR framework to come up with secure design by selecting security design patterns for the domain specific application such as e-commerce system.

The proposal of CAT (component aware techniques) is effectively using components that meet the stakeholders' needs for a component based application (CBA). Matching off-the-shelf (OTS) components, using a representation of OTS components as an aggregate of their functional and non-functional requirements and architecture is an important activity. This paper explores the relationship between matching effectiveness with the richness of OTS component structure illustrated using a home appliance control system (HACS) example. Intuition tells that the richer the structure of OTS component, the more effective the matching is. This paper shows positive relationship between OTS model richness and matching effectiveness with experimental study.

An interesting practical problem is the relationship of the non-functional requirements (or NFRs) of constituents of software architecture to the architecture. For example, if the constituents of a software architecture are adaptable (reliable, secure, usable, etc.), will the software architecture itself be adaptable (reliable, secure, usable, etc.)? It is generally accepted that the constituents of the software architecture are components, connections, constraints, styles and patterns. And, as a corollary, what is the minimum number of constituents that need to possess the NFR? This paper explores these problems for an industrial telecom system that is used as a case study and concentrates on a specific NFR, namely, adaptability. Employing the NFR framework for justification, this paper concludes that possession of the NFRs by the constituents is helpful for the final software architecture to possess that NFR. This paper also develops heuristics on how many constituents need to possess the NFR so that the final architecture possesses the NFR.

There has been extensive research on establishing a non-functional requirement (NFR) framework (Chung et al., 2000) and applying it systematically in selecting software architectural design alternatives. However there is still a gap between software architecture and concrete detailed design. This paper presents a way to come up with more detailed designs by selecting a set of applicable design patterns. The method in selecting design patterns is applied step by step systematically in a defined process. After a preliminary selection of a set of potentially applicable design patterns based on existing knowledge, analysis of their applicability is conducted on each of the design patterns. In each analysis process, the potentially applicable design pattern and the chosen architectural design are decomposed; the traceability from software architecture to design patterns is analyzed. This method is applied in the case study on keyword in context system (KWIC) (Shaw and Garlan, 1996) and (Chung et al., 2000). The notation of NFR approach (Chung et al., 2003) is further refined.

Abstract Evolution of a software system is a natural process. In most systems, evolution takes place during the maintenance phase of their life cycles. Those systems that have reached their limit in evolution have usually reached their end of useful life and may have to be replaced. However, there are systems in which evolution occurs during the operational phase of their life cycles. Such systems are designed to evolve while in use or, in other words, be adaptable. Semantically adaptable systems are of particular interest to industry as such systems often times adapt themselves to environment change with little or no intervention from their developing or maintaining organization. Since embedded systems usually have a restricted hardware configuration, it is difficult to apply the techniques developed for non‐embedded systems directly to embedded systems. This paper focuses on evolution through adaptation and develops the concepts and techniques for semantic evolution in embedded systems. As the first step in the development of a software solution, architectures of software systems themselves have to be made semantically evolvable. In this paper we explore various architectural alternatives for the semantic evolution of embedded systems—these architectures are based on four different techniques that we have identified for semantic evolution in embedded systems. The development of these architectures follows the systematic process provided by the non‐functional requirement (NFR) framework, which also permits the architectures to be rated in terms of their evolvability. As the field of embedded systems is vast, this paper concentrates on those embedded systems that can be remotely controlled. In this application domain the embedded system is connected to an external controller by a communication link such as ethernet, serial, radio frequency, etc., and receives commands from and sends responses to the external controller via the communication link. The architectures developed in this paper have been partly validated by applying them in a real embedded system—a test instrument used for testing cell phones. These architectures and techniques for semantic evolution in this application domain give a glimpse of what can be done in achieving semantic evolution in software‐implemented systems. Copyright © 2003 John Wiley & Sons, Ltd.

The goals of developing systems better, faster, and cheaper continue to drive software engineering practitioners and researchers to investigate software engineering methodologies. In requirements engineering, the focus has been on modeling the software engineering process and products for systems that are being built from scratch. As the size and complexity of systems continues to grow the use of commercial off the shelf (COTS) components is being viewed more and more as a promising, and also perhaps inevitable, solution. The effective use of COTS components, however, requires a systematic approach that provides a set of concepts for modeling the subject matter, a set of guidelines for using such concepts, and tool support to assist the developer.In this paper, we present a COTS-Aware Requirements Engineering (CARE) approach that explicitly supports the use of COTS components. Our CARE approach is knowledge based, has a defined process, and is agent- and goal-oriented. In particular, we present part of our meta-model for the knowledge base and a prototype of the CARE Assistant Tool. Our CARE approach is validated using a part of a Digital Library System example.

Evolution of a software system is a natural process. In many systems evolution occurs during the working phase of their lifecycles. Such systems need to be designed to evolve, i.e., adaptable. Semantically adaptable systems are of particular interest to industry as such systems adapt themselves to environmental change with little or no intervention from their developers. Research in embedded systems is now becoming widespread but developing semantically adaptable embedded systems presents challenges of its own. Embedded systems usually have a restricted hardware configuration, hence techniques developed for other types of systems cannot be directly applied to embedded systems. This paper briefly presents the work done in semantic adaptation of embedded systems, using remotely controlled embedded systems as an application. In this domain, an embedded system is connected to an external controller via a communication link such as ethernet, serial, radio frequency, etc., and receives commands from, and sends responses to, the external controller. Techniques for semantic evolution in this application domain give a glimpse of the complexity involved in tackling the problem of semantic evolution in embedded systems. The techniques developed in this paper were validated by applying them in a real embedded system - a test instrument used for testing cell phones.

Proposes the POMSAA (Process-Oriented Metrics for Software Architecture Adaptability) framework, which aims to provide numeric scores representing the adaptability of a software architecture, as well as the intuitions behind these scores. In this framework, the intuitions behind the architectural adaptability scores are traced back to the "whys" of the architecture, namely the requirements for which the architecture exists in the first place. POMSAA achieves the needed tracing by adopting the NFR (Non-Functional Requirements) framework, which is a process-oriented qualitative framework for representing and reasoning about non-functional requirements. We show how to use POMSAA to: (1) calculate and re-calculate the metrics; (2) detect weaknesses and strategic strengths; (3) understand the reasons for those weaknesses and strengths; and (4) make the needed changes to the architecture to increase its adaptability.

Software architectural design is becoming increasingly important in software engineering, as being manifested through various recent developments in the field such as the component-based software engineering paradigm and the distributed and collaborative computing paradigm. Abstraction is such a mechanism as the key concept underpinning software architecture, namely hiding the immense amount of details. Despite its long-recognized benefits, however abstraction can also pose difficulties with the understanding and analysis of software architecture since one architecture can result in potentially an infinite number of different system behaviors. In order to alleviate such difficulties, we introduce the notion of dynamic software architecture slicing (DSAS), a methodology for using the notion, and an algorithm to generate dynamic software architecture slice. We demonstrate the feasibility and the expected benefits of the approach by using an illustrative example.

The existing Z supporting tools focus on providing editing and syntax checking functionalities (Siddiqi et al., 1993). We develop VZ (Visual Z) visual programming environment for constructing Z specifications. The main advantage of such an environment is to allow the user to manipulate icons (glyphs) to generate a specification. Instead of remembering the set of Z symbols, the user can manipulate the visually understandable icons to develop the specification. Moreover, VZ is a well organized environment; various components of a specification are organized into different folders for easy storage and retrieval. Finally, VZ also supports validation of specification and basic logic proving, which are essential in developing correct specification.

Quality characteristics are vital for the success of software systems.To remedy the problems inherent in ad hoc development, a framework has been developed to deal with non-functional requirements (quality requirements or NFRs).Taking the premise that the quality of a product depends on the quality of the process that leads from high-Ievel NFRs to the product, the framework's objectives are to represent NFR-specific requirements, consider design tradeoffs, relate design decisions to IYFRs, justify the decisions, and assist defect detection.The purpose of this paper is to give an initial evaluation of the extent to which the framework's objectives are met.Three small portions of information systems were studied by the authors using the framework.The framework and empirical studies are evaluated herein, both from the viewpoint of domain experts who have reviewed the framework and studies, and ourselves as framework developers and users.The systems studied have a variety of characteristics, reflecting a variety of real application domains, and the studies deal with three important classes of NFRs for systems, namely, accuracy, security, and performance.The studies provide preliminary support for the usefulness of certain aspects of the framework, while raising some open issues.

Non-functional requirements (or quality requirements, NFRs) such as confidentiality, performance and timeliness are often crucial to a software system. Our NFR-framework treats NFRs as goals to be achieved during the process of system development. Throughout the process, goals are decomposed, design tradeoffs are analysed, design decisions are rationalised, and goal achievement is evaluated. This paper shows how a historical record of the treatment of NFRs during the development process can also serve to systematically support evolution of the software system. We treat changes in terms: of (i) adding or modifying NFRs, or changing their importance, and (ii) changes in design decisions or design rationale. This incremental approach is illustrated by a study of changes in banking policies at Barclays Bank.

A comprehensive framework for representing and using nonfunctional requirements during the development process is proposed. The framework consists of five basic components which provide the representation of nonfunctional requirements in terms of interrelated goals. Such goals can be refined through refinement methods and can be evaluated in order to determine the degree to which a set of nonfunctional requirements is supported by a particular design. Evidence for the power of the framework is provided through the study of accuracy and performance requirements for information systems.>

The features of a compiler for the Taxis design language are described and discussed. Taxis offers an entity-based framework for designing interactive information systems and supports generalisation, classification and aggregation as abstraction mechanisms. Its features include multiple inheritance of attributes, isA hierarchies of transactions, metaclasses, typed attributes, a procedural exception-handling mechanism and an iteration construct based on the abstraction mechanisms supported Developing a compiler for the language involved dealing with the problems of efficiently representing and accessing a large collection of entities, performing (static) type checking and representing isA hierarchies of transactions.