Due to the lack of central control in distributed systems, design and implementation of such systems is a challenging task. Interaction of multiple autonomous components can easily result in unwanted behavior in the system. Therefore it is vital to carefully review the design of distributed systems. Manual review of software documents is too inefficient and error prone. It would therefore be beneficial to have a systematic methodology to automatically analyze software requirements and design documents. However automating the process of software analysis is a challenging task because besides the design know-how, each software system requires its own domain knowledge. Existing approaches often require a great deal of input from system engineers familiar with the domain. Such information needs to be interpreted by the designer which is a time-consuming and error prone process. This research suggests the use of a scenario-based approach to represent system requirements. Scenarios are often depicted using message sequence charts (MSCs). Due to their formal notation, MSCs can be used to analyze software requirements in a systematic manner. In an earlier paper, it was demonstrated that ontologies can be used to effectively automate the construction of domain knowledge for the system. However the construction of ontologies remained a challenging task. This paper describes a process which infers ontology from the provided message sequence charts. Furthermore this paper introduces a software tool which automates the process of domain ontology construction. This methodology is demonstrated using a case study of a fleet-management software system.

In this paper, a novel algorithm is proposed to transform a ROM diagram obtained from a design text into a FBS model. Each state of the transformation process is defined by four features: ROM (Recursive Object Model), POS (Part of Speech), PES (Product–Environment System), and FBS (Function–Behavior–State). The transformation algorithm is thus constituted by transition rules which change one transformation state to another, and procedures which apply the transition rules to a given ROM diagram. A software prototype R2FBS is presented as a proof of concept to assist the transformation. Two examples are used to demonstrate how the proposed approach works.

Global influence factors, e.g., quality attributes or technical constraints, often guide the process of designing software architectures. However, characteristics of individual requirements (e.g., the complexity or volatility of a requirement) also impact the design of architectures. Consequently, systematically handling the impact of individual requirements on the architecture can facilitate the design of architectures. Thus, we propose a method for identifying architecture-relevant structures in a set of requirements, based on characteristics of individual requirements. These structures provide information about when, where, how and why to implement requirements in the architecture. We use clustering to identify structures in requirements that are not apparent from functional decomposition or aggregation of requirements. Results from a case study show how these structures help with architecture design.

Multi-agent systems (MAS) are efficient solutions for commercial applications such as robotics, business commerce applications, information retrieval and search engines. In MAS, agents are usually designed with distribution of functionality and control. Lack of central control implies that the quality of service of MAS may be degraded because of possible unwanted behavior at runtime, commonly known as emergent behavior. Detecting and removing emergent behavior during the design phase of MAS will lead to huge savings in deployment costs of such systems. Effective and efficient design validation of MAS requires the development of systematic and automated methodologies to review MAS design documents. Although the increasing demand for MAS in the software industry has led to the development of several Agent Oriented Software Engineering (AOSE) methodologies, the AOSE methodologies usually do not fully cover monitoring and testing. In this paper, a technique to help MAS developers verify, test and monitor MAS design is introduced. This method uses MAS analysis and design artifacts created by the MaSE AOSE methodology. In this technique, design artifacts of MaSE are converted to scenario-based specification, which is very similar to UML's sequence diagrams. Then the specifications are used to analyze the system for validating the design of MAS and ensuring the lack of emergent behavior.

A survey about academic integrity issues was administered to 473 undergraduate engineering students from 12 universities in the United States and 6 universities outside of the United States. The survey posed questions about students' opinion of what types of actions do or do not constitute cheating, about student motivations for cheating or not cheating, student perceptions of how frequently their peers engage in academically dishonest activities, perception of faculty efforts to inhibit and punish cheating, and the degree to which students themselves (or external forces) should be held responsible for academically dishonest behavior when it occurs. Comparisons of proportions were conducted to identify statistically significant (alpha = .05) differences in survey responses between domestic and international students.Significant differences between the two populations were observed relative to the number of students who admit to cheating, the frequency with which they engage in academically dishonest behavior, student motivations for cheating, and student impression of how much their peers cheat.

There are many factors that provide input into the software development process, such as the values, beliefs, norms, practices, skills, behaviors, knowledge and goals of stakeholders. Research has shown that successful software system development relies on alignment or congruence between these factors. How to monitor the level of congruence between these factors and how to use the congruence as an indicator or a measure to monitor a software development process is a challenge in software engineering. This paper proposes a model that uses three congruence measures to examine the levels of social-technical congruence in software development processes. Using a controlled experiment with seven student teams developing a robot project, this paper demonstrates that the proposed congruence measures provide results consistent with the assessment by the course lecturers.

Emergent behavior in distributed systems is a central problem that may lead to unexpected behaviors and major faults. Emergent behaviors are usually categorized into three groups: emergent behaviors occur due to scenarios incompleteness; emergent behaviors as a result of violation of a system wide policy; and emergent behaviors as a result of synthesis of behavior models. In this paper, a technique for addressing the latter group is proposed. The technique prevents from overgeneralization in the behavior model synthesis. Overgeneralization happens as the result of behavior model synthesis and depends on the assumptions of the process. In addition, the proposed technique addresses the issue of the existing ad-hoc methodologies by providing an automated algorithm. This algorithm can be used by a syntax checker to automatically detect and correct the emergent behaviors in the scenarios. The proposed algorithm is validated using a case study of a fleet management system.

Network filtering has become an important security issue worldwide. Network filters are designed and put in place to enforce restrictions for a variety of different motives, such as political, social, economical or merely security reasons. Although network filters can be applied to different networks, their main use is for the Internet. However, as is the case with most network security measures, many network filters are bypassed by users and thus are not completely adequate to perform their tasks. This paper approaches the network filtering concepts from a software engineering perspective. The general purpose of this approach is to utilize automated methodologies to analyze the correctness of the requirements of the filtering mechanisms, and to reduce their vulnerability. In order to achieve this, requirements are expressed using scenario-based specifications. The resulting scenarios are then analyzed for unwanted behavior using automated methodology. To demonstrate the effectiveness of this approach, it is applied to the case study of a real-life Internet-filtering system.

The quality of information systems heavily depends on software requirements engineering and software architecting. Both activities are the foundation for subsequent tasks, such as software development project planning, implementation, or maintenance. This paper introduces a methodological framework to support the transition from requirements to architectures. The framework consists of a process and different process modules (e.g., for systematic software architecture style selection). We also present a case study which shows higher modularity and lower coupling of architectures created using the proposed framework when compared to architectures created without the framework.

The growing complexity of software has posed challenges for the design, understanding and maintenance of software. Software developers often spend a lot of effort on understanding how software components are connected. Through analysis of the data obtained from a real software application, this paper demonstrates that network analysis approaches can help understand software component interconnections and their impact on software quality. Additionally, this paper shows that there is a correlation between the number of bugs found in an application and a set of measures used in component (interconnection) networks. Furthermore, a case study showed that the software performance improved over two releases as a result of improving the component network.

Recommendation systems provide users with up-to-date guidance on processes, artifacts or other project-relevant information. Recommendation systems for requirements engineering can be used to provide the right information, at the right time, to requirements engineers. In this paper, we use systematic mapping to provide an overview of recommendation systems for the requirements engineering process, their characteristics, and state of validation. The resulting maps are analyzed to provide conclusions and to identify the limitations of current studies, and future research areas. The results of the mapping are used to outline the motivation for our future work on a recommendation system that helps product managers decide on the assignment of requirements to subsequent releases while considering constraints such as time, effort, quality, and resources.

Distributed knowledge has attracted more and more attention as a way to improve knowledge sharing across the world using the Internet. This paradigm enables many systems to interact with each other and share their knowledge while keeping their own ontology. Several researchers have worked on this topic with different strategies but they all argue that the main issue is to make sure that the other systems understand the concepts of its domain correctly. In order to be sure that they understand each other, systems use concept learning to learn the meaning of concepts they communicate with. In this paper, we try to overcome this complexity by suggesting a system that enables agents to learn new concepts from several different agents at the same time and each agent has its own ontology. We use social networks paradigm to communicate between agents to enhance the accuracy of learning process.

Variability in service-oriented architectures (SOA) is usually addressed through loose coupling of services and dynamic retrieval, composition and binding of services. Facilitating variability can lead to different instances of one SOA. These instances share commonalities, but vary in certain aspects (e.g., in functionality or quality attributes). Current service-based development approaches do not adequately address variability and the management of different SOA instances. To handle different instances and to support systematic variability management, different instances of a service-based system may be treated as members of a product line. Therefore, we present a light-weight method to decide on what services to add to service-based systems to facilitate the transition from individual systems to a service-oriented product line. When adding services to service-based systems, the structural stability of these system decreases. We argue that a decrease in structural stability must be justified by additional value provided by the enhanced service-based systems. Based on the enhanced systems, our method then identifies potential core asset services for a service-oriented product line, taking into account common services within the different systems. Here, core asset services are reusable services that occur in any instance of the SOA. Thus, our method helps with the transition from individual products to a product line. A case study is included to illustrate our method.

I declare that this paper is my own work and that information derived from published or unpublished work of others has been acknowledged in the text and has been explicitly referred to in the list of references. All citations are in the text between quotation marks (" "). I am fully aware that violation of these rules can have severe consequences for my study at Utrecht University.

Using Commercial Off-The-Shelf (COTS) products to build software systems requires the evaluation of existing COTS products, the selection of the COTS that best fit system requirements, and the integration of the selected COTS into the system. During this process, it is inevitable to encounter two types of mismatches: (1) COTS mismatches, which are encountered during COTS selection between requirements and COTS features, due to an excess or shortage of COTS features, and (2) architectural mismatches, which arise when integrating multiple COTS products that do not fit well together. This paper focuses on the ‘COTS mismatch’ problem. The paper describes a real-world case study of a single COTS selection with the aid of a method called MiHOS (Mismatch Handling for COTS Selection) to handle the COTS mismatches. MiHOS runs on top of existing COTS selection models in order to properly address COTS mismatches with limited resources. The case study was conducted in the e-service domain. The goal was to validate MiHOS and to answer two key questions: (1) How useful is decision support during different phases in the process mismatch handling? And (2) what is the effort vs benefit of using MiHOS? The results are promising and illustrate the potential benefits of using MiHOS. Copyright © 2011 John Wiley & Sons, Ltd. (This research has been conducted at the University of Calgary as a partial fulfilment of the requirements for the degree of PhD.)