Mahmood Moussavi

Lightweight Replanning of Software Product Releases

Well defined product features are the essence of good product management. High quality features lead to successful software products, both functionally and financially. One of the crucial processes in software product management is release planning where features are assigned to releases. Volatile features, resources and stakeholder preferences have been recognized as factors that decrease release quality. In this paper, we propose a lightweight replanning process model where old features are compared with newly added ones using the Analytical Hierarchy Process (AHP). Then, a greedy replan algorithm is applied to select the most promising features to accommodate changing market driven product demands.

Systematic selection of software architecture styles

Selecting appropriate styles for software architectures is important as styles impact characteristics of software (e.g. reliability). Moreover, styles influence how software is built as they determine architectural elements (e.g. components, connectors) and rules on how these elements are integrated in the architecture. Therefore this study presents a method, called SYSAS, for the systematic selection of architecture styles. In SYSAS, style selection is based on (a) characteristics of basic architectural elements that are relevant for the developer, and (b) characteristics of the target system that are visible to the end user. The selection procedure requires ratings about the importance of characteristics of architectural elements and results in a ranking of styles. SYSAS can be applied at system level as well as for choosing styles for individual subsystems. A case study is presented to illustrate SYSAS and its applicability and added benefit. Additional case studies are performed to compare results of SYSAS with judgements of experts.

Transition from Requirements to Architecture: A Review and Future Perspective

Elicitation, modeling and analysis of requirements are main challenges during software development. In parallel, software architectures have become a well established area in software engineering research and practice. However, there is still a lack of fundamental process models and guidelines for the transition between the two important phases of requirements engineering and software architectures within the software development cycle. Substantial progress has been separately made in both areas but very little research achievements can be found that address the relation between requirements and architectures. When doing a review on existing methods that try to overcome this gap we realized an urgent need for fundamental research in this area. The paper first presents, compares, classifies and evaluates the suitability of current approaches. Then, evaluation criteria and requirements for a transition methodology are defined. Finally, directions for further research are presented

Detecting emergent behavior in distributed systems using an ontology based methodology

Lack of central control makes the design of distributed software systems a challenging task because of possible unwanted behavior at runtime, commonly known as emergent behavior. Developing methodologies to detect emergent behavior prior to the implementation stage of the system can lead to huge savings in time and cost. However manual review of requirements and design documents for real-life systems is inefficient and error prone; thus automation of analysis methodologies is considered greatly beneficial. This paper proposes the utilization of an ontology-based approach to analyze system requirements expressed by a set of message sequence charts (MSC). This methodology involves building a domain-specific ontology of the system, and examines the requirements based on this ontology. The advantages of this approach in comparison with other methodologies are its consistency and increased level of automation. The effectiveness of this approach is explained using a case study of an IntelliDrive system.

Comparing methodologies for the transition between software requirements and architectures

The transition from software requirements to software architectures has consistently been one of the main challenges during software development. Various methodologies that aim at helping with this transition have been proposed. However, no systematic approach for assessing such methodologies exists. Also, there is little consensus on the technical and non-technical issues that a transition methodology should address. Hence, we present a method for assessing and comparing methodologies for the transition from requirements to architectures. This method also helps validate newly proposed transition methodologies. The objective of such validations is to assess whether or not a methodology has the potential to lead to better architectures. For that reason, this paper discusses a set of commonly known but previously only informally described criteria for transition methodologies and organizes them into a schema. In the paper we also use our method to characterize a set of 14 current transition methodologies. This is done to illustrate the usefulness of our approach for comparing transition methodologies as well as for validating newly proposed methodologies. Characterizing these 14 methodologies also gives an overview of current transition methodologies and research.

Early assessment of software architecture qualities

This paper presents an approach for the ad-hoc assessment of software architecture qualities. The method allows evaluating architectures at early development stages and focuses on development qualities (e.g., coupling), rather than on runtime qualities (e.g., performance). Early feedback in the development process facilitates immediate improvement of low quality architecture artifacts. The proposed method defines three levels of architecture quality attributes, some of which are expressed as computable metrics while the other quality attributes are derived from these metrics. Throughout the paper, the example of a cruise-control system illustrates the approach.

Towards automated HPC scheduler configuration tuning

High performance computing (HPC) systems allow researchers and businesses to harness large amounts of computing power needed for solving complex problems. In such systems a job scheduler prioritizes the execution of jobs belonging to users of the system in a manner that allows the system to satisfy performance objectives for various groups of users while simultaneously making efficient use of available resources. Typically, system administrators have the responsibility of manually configuring or tuning the job scheduler such that the performance objectives of user groups as well as system‐level performance objectives are met. Modern job schedulers used in production systems are quite complex. Through detailed trace‐driven simulations, we show that manually tuning the configuration of production schedulers in an environment characterized by multiple performance objectives is very challenging and may not be feasible. To alleviate this problem, this paper describes a toolset that can help a system administrator to automatically configure a scheduler such that the performance objectives for various classes of users in the system as well as other system‐level performance objectives can be satisfied. A unique aspect of this work that differentiates it from the existing work on scheduler tuning is that it has been implemented to work with a widely used production scheduler. Furthermore, in contrast to the existing work it considers the challenging real‐world problem of delivering different levels of performance to different classes of users. System administrators can exploit the toolset to react quickly to changes in performance objectives and workload conditions. Case studies using synthetic and real HPC workloads demonstrate the effectiveness of the technique. Copyright

A stochastic time series generator with adaptive software architecture

Stochastic time series are preferred to historic data series of shorter duration since they contain sequences that may not be observed in a relatively short historic record. Algorithms to generate stochastic time series from historic data have already been proposed. In this paper we present an implementation of an efficient stochastic time series generation algorithm and a component based front-end software system for it. The algorithm is built as three distinct and customizable components. The component based architecture allows for seamless selection of the processing steps as well as integration of new algorithms. The system has been tested successfully on several numerical experiments using hydrologic time series data to generate lengthy (1000 years) of weekly or monthly river flows for multiple locations such that all relevant statistics of the historic series are preserved in the generated series.

Balancing value and modifiability when planning for the next release

Planning the next release in software release planning addresses the problem of assigning features to the next release such that technical, resource, risk, and budget constraints are met. This paper studies the planning for the next release of an evolving system from a bi-criteria perspective. We introduce a method called NRP-trade-off to adjust baseline release plans for more modifiability by replacing lower value features with features having a higher modifiability. For that purpose, we include a new approach for feature modeling and assessing modifiability by applying object-oriented design metrics to the feature domain. We also briefly introduce a case study.

Parameterized strategy pattern

The Strategy pattern decouples algorithms from the class that uses them allowing the algorithms to vary independently. It does not, however, allow the algorithms to have different parameters. The parameterized strategy pattern presented in this paper addresses the case when the algorithms have different sets of parameters, and when the user is allowed to see and modify these parameters for each concrete algorithm before its execution. This is accomplished by introducing special parameter classes which encapsulate algorithms parameters. The abstract algorithm class is completely decoupled from parameters letting each concrete algorithm class to create its own list of parameter instances which mirrors its parameters.