- Research Article
- 10.1002/smr.1763
Guest editors' introduction
- Dec 06, 2015
- Journal of Software: Evolution and Process
- Liguo Huang + 2 more +2
Guest editors' introduction
Experience with software process simulation and modeling
Guest editors' introduction
Guest editors' introduction
A systematic map on verifying and validating software process simulation models
Verification and Validation (V&V) is a critical step in software process modelling to secure the model's quality and credibility. Software Process Simulation Models (SPSMs) that are based on descriptive process models offer the executability that is able to demonstrate the dynamic changes of software process over time. The V&V of process simulation models go beyond static process models and turn to be more complex and challenging to software modelers. This study aims to identify what aspects of process simulation models are verified and validated by using which V&V methods in what conditions in software engineering research. We conducted a systematic literature review (mapping study) on the studies of software process simulation that report of their V&V activities. We identified 72 relevant studies from a pool of 331 papers on SPSM until 2015. These studies can be mapped to ten V&V methods applied for five aspects of process models to be verified and validated, i.e., syntactic quality, semantic quality, pragmatic quality, performance, and value. A systematic map is presented to illustrate the relationships between the identified V&V methods and their supporting aspects of process models. This mapping will provide the community reference value when developing, verifying, and validating software process (simulation) models.
Read moreProSim'04-the 5th international workshop on software process simulation and modeling
The complex challenges currently faced by software development companies must be handled in a dynamic project environment of frequently changing technologies, short-staffed projects and globally distributed development teams. Globalization is forcing companies to significantly cut costs in order to be competitive. Amid these pressures, new software development lifecycle process alternatives have emerged from agile methods, such as extreme programming, to well-planned product line development. Open source software development is ramping up. At the same time, many projects are being contracted out, either in whole or in part. Subsequently, software may be developed in multiple locations around the world, resulting in a greater need for good communication and co-ordination. Security assurance is another issue that requires increased attention. The goal of this workshop is to bring together academics and practitioners interested in the area of software process modeling and simulation and in important industrial issues related to cost estimation and business process design. ProSim 2004 continues the tradition set in previous workshops of serving as an international forum for presenting current research themes and applications, and for discussing various approaches to discover underlying similarities at both the applied and theoretical levels. In particular, this workshop will solicit research dealing with both the application of software process simulation research in addressing real-world problems, as well as advances being made which provide the foundation for Software Process and Software Process Simulation Modeling in the future. 2. Topics of interest
Read moreProSim'04-the 5th international workshop on software process simulation and modeling
The complex challenges currently faced by software development companies must be handled in a dynamic project environment of frequently changing technologies, short-staffed projects and globally distributed development teams. Globalization is forcing companies to significantly cut costs in order to be competitive. Amid these pressures, new software development lifecycle process alternatives have emerged from agile methods, such as extreme programming, to well-planned product line development. Open source software development is ramping up. At the same time, many projects are being contracted out, either in whole or in part. Subsequently, software may be developed in multiple locations around the world, resulting in a greater need for good communication and co-ordination. Security assurance is another issue that requires increased attention. The goal of this workshop is to bring together academics and practitioners interested in the area of software process modeling and simulation and in important industrial issues related to cost estimation and business process design. ProSim 2004 continues the tradition set in previous workshops of serving as an international forum for presenting current research themes and applications, and for discussing various approaches to discover underlying similarities at both the applied and theoretical levels. In particular, this workshop will solicit research dealing with both the application of software process simulation research in addressing real-world problems, as well as advances being made which provide the foundation for Software Process and Software Process Simulation Modeling in the future. 2. Topics of interest
Read moreMetrics for software process simulation modeling
Software process simulation (SPS) has become an effective tool for software process management and improvement. However, its adoption in industry is less than what the research community expected due to the burden of measurement cost and the high demand for domain knowledge. The difficulty of extracting appropriate metrics with real data from process enactment is one of the great challenges. We aim to provide evidence‐based support of the process metrics for software process (simulation) modeling. A systematic literature review was performed by extending our previous review series to draw a comprehensive understanding of the metrics for process modeling following our proposed ontology of metrics in SPS. We identify 131 process modeling studies that collectively involve 1975 raw metrics and classified them into 21 categories using the coding technique. We found product and process external metrics are not used frequently in SPS modeling while resource external metrics are widely used. We analyze the causal relationships between metrics. We find that the models exhibit significant diversity, as no pairwise relationship between metrics accounts for more than 10% SPS models. We identify 17 data issues may encounter in measurement and 10 coping strategies. The results of this study provide process modelers with an evidence‐based reference of the identification and the use of metrics in SPS modeling and further contribute to the development of the body of knowledge on software metrics in the context of process modeling. Furthermore, this study is not limited to process simulation but can be extended to software process modeling, in general. Taking simulation metrics as standards and references can further motivate and guide software developers to improve the collection, governance, and application of process data in practice.
Read moreCoordinate metrics and process model to manage software project risk
Purpose of this paper is to analyze and evaluate risks in software development process quantitatively; evaluate risks influence upon project's object, and assist management decision based on risks. The primary content of this paper is to discuss the software metrics space which support software process modeling and risk quantitative analysis, research modeling method for software process and discuss risk management method under the risk management framework of coordinating software metrics and process model. The authors bring forward software project risk management framework coordinating software metrics and process model, present a new software metrics hypercube space, construct software process two level hybrid model based on general stochastic Petri net, and suggest risk management technique coordinating software metrics and software process model
Read moreSoftware process support through software configuration management
Software development embodies a range of software processes. Such processes can be captured in software process models. Two of the reasons for describing software processes through models are to document and communicate a particular process to others, and to encode knowledge of the process in a form processable by computer. Software process modeling has received attention by researchers in recent years - as this series of workshop indicates. Efforts are expended on determining what processes are to be modeled, what of power of the modeling language is, and how the model can be instantiated and executed.This position paper examines a different trend to supporting software processes. Software development environments (SDE) support the evolution of software through teams of developers by providing software version and configuration management and system build functionality. This SDE functionality supports and embodies certain aspects of the software process. We have examined and experimented hands-on with a number of commercial software development environments. The environments include the Rational Environment, Apollo DSEE, Sun NSE, IST Istar, BiiN SMS, and Atherton Software Backplane. These environments have advanced the functionality provided to support software evolution over commonly used development support tools such as Unix Make/RCS, and DEC VMS MMS/CMS.A number of observations can be made about these environments and the way they have attempted to - at least partially - capture (i.e., instantiate) software processes.Separation of mechanisms and policy: This notion has been in practice in operating systems for a number of years. The primitives (mechanisms) should be abstract enough to contain some of the semantics of the process model to be instantiated. For example the concept of managed workspace or transaction provides a higher-level abstraction than the check-out/check-in primitives and a working directory. A good set of primitives does not unnecessarily restrict the ability to build desirable executable process models. Such restrictions are detected when process model instantiations and executions are attempted. For example, the check-out operation usually performs two functions - making a program unit modifiable, and locking the unit to prevent concurrent modification. If optimistic development (i.e., permit concurrent development) is to be supported the user would have to resort to the branching function. Sun NSE directly supports optimistic development, but currently does not provide the primitives to provide serialized development (i.e., locking). Policies can generally be encoded by writing an envelope of functions on top of the available primitives. In summary, slow progress is being made in separation of mechanism and policy and in encoding process models.Source code control evolves to software configuration management: Development support in common practice provides source code control for individual files and a system build facility. Newer SDEs have expanded their functionality to support object code management, management of configurations, transparent access to source repositories, management of work areas, and primitives for reflecting development activities. In doing so, they relieve developers from managing versions of object code themselves, from constantly retrieving copies of files from the repository for viewing purposes, and from concerning themselves with the version history of individual files while being focused on evolving a system. The models embedded in the functionality of these environments are often not clearly described by the manufacturer, and sometimes best understood when related to the model in another environment.Configuration composition vs. evolution: These are two major approaches in maintaining configurations. Configuration composition refers to defining a configuration template, which lists the components. Together with a set of selection criteria, this template can be instantiated into a bound configuration. The binding may take several steps, such as source variant selection, version selection, tool version selection, and tool parameter selection. Appropriate selection criteria allow for a range of desirable configuration instantiations. such as experimental, conservative, or stable. Apollo DSEE is an good example of this approach. The evolution approach is reflected in environments such as Sun NSE. The user initially creates a system configuration, populates it with elements, and preserves it. Changes to the system are performed relative to a preserved configuration. Most configuration management operations are performed at the level of configurations, while versioning of individual files is largely transparent. The Rational Environment is an environment that combines the two approaches. Each of the two major approaches gives different perspective of a development process.Repository-oriented vs. transaction-oriented: Again, two major approaches in managing software evolution will create different perceptions of a development process. The repository-oriented approach (or product-oriented approach) centers its support for development management on the products to be managed. The history of product evolution is reflected in the repository and its organization. Environments, such as BiiN SMS, have applied the repository mechanisms to provide for management of the work area. The transaction-oriented approach (or process-oriented approach) is centered around the changes and the activities necessary for the changes. Istar is an example of a purely process-oriented support facility by directly modeling development steps and integrating it with project planning. Other transaction-oriented environments, such as Sun NSE, take a more modest approach by providing nested transactions as a key concept. A transaction plays the role of a change activity. A transaction log reflects product history. Non-terminating transactions act as repositories. As a matter of fact, one can find a spectrum of environment support ranging from repository-oriented to transaction-oriented: repository, work area management, nested transactions, activities/tasks, trigger-based task instantiation, and plan-based task instantiation.Concurrency and coordination: Some environment builders have recognized the need for different degrees of freedom in concurrency and coordination of development. A closely cooperating team of developers working on a particular subsystem want more freedom passing partially complete pieces among themselves than developers of different subsystems. Some environments are supporting both a cooperating team producing the next configuration releasable outside the team, and teams independently working on different development paths of the same subsystem (e.g., field release with bug fixes and further development) or different subsystems (i.e., partitioning of the system). This is new functionality and different environments provide different degrees of freedom.Scopes of visibility: Related to the previous point is the desire to provide scopes of visibility. Individual developers should be able to made snapshots of their work by freezing a configuration without making it visible to others. Developers should be able to make their work available to their team mates before it becomes visible to a test team or the general public. Various approaches are being tried. Use of access control mechanisms seems to be an obvious choice, but they tend to be one of the least developed areas in environments. The use of multiple repositories (one for each scope of visibility) has the problem of potentially high cost of recompilation as elements are moved from repository to repository. Some repository mechanisms provide a viewing mechanism based on a status attribute. Different users are limited to viewing elements with different attribute values. Evolution-oriented environments utilize nested transactions to reflect restrictions in visibility of changes.The above reflects the state-of-the-art in commercial software development environments and their support for the process of software evolution. Many of these environments are reasonably robust that they can be employed in real projects and scaled up to handle management of large system development. On one hand, it is encouraging to see that there is progress being made in the functionality provided by these environments. On the other hand it can be a little discouraging to see the limitations that exist in capturing software processes, validating their model, instantiating them, and evolving and adapting them. This is, where researchers in the area of processing modeling can provide guidance to environment builders as to appropriate mechanisms to be made available, as well as facilities for capturing process models, executing them, and allowing for adaptations and changes during execution.
Read moreApplication of 80/20 rule in software engineering Waterfall Model
Software process is the most important part of software project management, and software process models are important means of implementing the software process in any software organization. When there is need to improve the software process, then the need to improve the work-task part (software process models) of the software process must arise. As, there is need of increasing the commitment of software project managers through out the software development life cycle (SDLC), so we need to give them the list of activities in Waterfall Model, which should be made efficient by the software development team, to get the 80% productivity (output) easily, by reducing the effort of software development and ultimately increasing the performance of the software process. So, the idea of 80/20 rule (Pareto Principle, 1935) can be applied in the software engineering process model, in this regard. The Pareto Principle (1935) directed us to focus on what is really important in any field and field's work. Software process is most important part of software project management (SPM). This is also then ultimately needed for software project management (SPM) improvement. Our main research work is to improve the work-task part of the software process (i.e. software process models by applying the Pareto Principle - 80/20 Rule (1935) (or law of vital few) (1935), in the software engineering process models (or work-task part of the software process). This will be to facilitate the software project manager, using the software process models practically more efficient than without application of 80/20 Rule in software engineering Waterfall model. This has resulted in the reduction of the software development effort and increase in the performance of the software process. The results (efficient and improved software process models) will be implemented in the software industry, by software project managers, by focusing on the list of activities giving 80 percent of the overall productivity of the software process. The results will be the list of activities having the capability to give 20 percent of the overall productivity of the software Waterfall process, to be ignored, eliminated or designated to reduce the effort.
Read moreSoftware Process Support Through Software Configuration Management
Software Process Support Through Software Configuration Management
Software process modeling: theory, results and commentary
As an emerging technology, the effectiveness and potential impact of process improvement efforts have been debated, but not fully tested or validated. At the very core of this technological evolution is the idea that the quality of a software product is highly dependent on the quality of the process used for its development. Branching from this central idea are three categories of innovations: process models; modeling techniques; and the novel concept of process maturity assessment. The purpose of this paper is to examine the current state-of-the-practice regarding software process models, modeling techniques and assessments. Particular attention is directed at a process improvement initiative, Humphrey's (1997) Personal Software Process.
Read moreSoftware Process Definition and Management
* First book that gives a comprehensive introduction into software process definition and management* It enables readers to develop useful process models that are suitable for their own purposes* Special chapters on measurement and determination of the effectiveness of processes The concept of processes is at the heart of software and systems engineering. Software process models integrate software engineering methods and techniques and are the basis for managing large-scale software and IT projects. High product quality routinely results from high process quality.Software process management deals with getting and maintaining control over processes and their evolution. Becoming acquainted with existing software process models is not enough, though. It is important to understand how to select, define, manage, deploy, evaluate, and systematically evolve software process models so that they suitably address the problems, applications, and environments to which they are applied. Providing basic knowledge for these important tasks is the main goal of this textbook.Mnch and his co-authors aim at providing knowledge that enables readers to develop useful process models that are suitable for their own purposes. They start with the basic concepts. Subsequently, existing representative process models are introduced, followed by a description of how to create individual models and the necessary means for doing so (i.e., notations and tools). Lastly, different possible usage scenarios for process management are highlighted (e.g. process improvement and software process simulation).Their book is aimed at students and researchers working on software project management, software quality assurance, and software measurement; and at practitioners who are interested in process definition and management for developing, maintaining, and operating software-intensive systems and services.
Read moreA Catalogue of Bad Smells for Software Process
Software processes play an important role in the software industry, as they influence the quality of the product and determine the efficiency of the company that develops these software products. To be used systematically in different projects, software processes need to be disseminated in the organization and continuously evaluated when one wants to understand their quality. The evaluation of a software process maintains and promotes its quality and evolution. However, if these evaluations happen from data directly collected from a process that has been applied to a given development project, process quality problems have already influenced the outcome of the process and possibly the software product. Software process models, commonly specified in a process modeling language (PML), specify in a standardized way the elements of a process and the appropriate interactions between them. In addition to assigning to the understanding, communication and execution of a software process in a company, process models offer an opportunity for them to be evaluated before their first execution or even to help identify problems in the process of ongoing projects. This paper presents a proposal to use the concept of bad smells in software process models with the objective of identifying possible disharmonies in the models. Initially bad smells of object-oriented code were analyzed and adapted to SPEM (Software & Systems Process Engineering Meta-Model) to generate a catalog. Subsequently a survey was carried out to validate the definitions, representations and possible impacts of the proposed bad smells, resulting in a validation that presented an overall rate of 86% agreement. It is expected that being possible to characterize bad smells for software processes, to enable their applicability in real software development process.
Read moreHybrid modeling and simulation for trustworthy software process management: a stakeholder‐oriented approach
SUMMARYProcess Management Model (PMM) and Process Simulation Model (PSM) are the critical infrastructural components of the Trustworthy Process Management Framework (TPMF), which involves a large and heterogeneous group of stakeholders in process modeling and simulation to improve process trustworthiness. Process Modeling Stakeholders (PMS) have different levels of dependency on various process modeling and simulation techniques. They may also possess different perspectives or concerns in modeling. To support trustworthy process management, this paper integrates the stakeholder‐oriented approach and hybrid simulation technique into software process modeling at three levels of abstraction (i.e., activity, sub‐process and system). The hybrid process simulation combines micro‐level discrete process models with the macro‐level continuous process models to capture process dynamics. In particular, the stakeholder‐oriented approach addresses the various perspectives of PMS during process modeling and simulation. Finally, a case study with a realistic process model demonstrates that this approach incrementally integrates stakeholders' modeling concerns through hybrid simulation, which is difficult to achieve using discrete or continuous modeling/simulation techniques independently. Copyright © 2010 John Wiley & Sons, Ltd.
Read moreThe role of process models in software and systems development and evolution
In seeking to maximise opportunity for achieving common understanding and real progress on specific issues, the announcement for the 5th Process Workshop adopts a somewhat narrow view of the role of Process Models. By so focussing the discussion, the fact that desirable characteristics of models will vary with the purpose for which they are to be used, the benefit one hopes to derive from their development or use and the value attached to benefit to gained from such activity has had to be disregarded. Yet process models can serve many purposes as summarised, for example, in the introduction to the Proceedings of the 4th workshop [SPW88] and also on the attached table. Though the roles included in that table are neither newly identified nor controversial they are listed so that they may be kept in the back of our minds as the Workshop discussion progresses.The individual importance of these roles can clearly not be ordered or even quantified. Their relative significance will depend on the goals of the work during which they are developed or used. The primary motivation underlying my work with process models over the past years has been the search for a better understanding of the software development and evolution process. This has led to conclusions which are, perhaps, self evident to many Computer Scientists, [DEM79], [FET88], [VAR79, 89] (as extreme examples) and others [BON77]. They are, however, not widely understood by the general public and, more importantly, by those involved in the definition and acquisition of computer systems for specific applications. In view of the increasing dependence of mankind on computers and, hence, on software it appears important to bring these, explicitly, into the open and to also examine their implications in the narrower confines of the topics discussed in the process workshop series.In the first instance my studies concentrated on an examination of models of program evolution in recognition of the fact that understanding and controlling that phenomenon demanded understanding and control of the programming process [LEH69, 85a]. This investigation led directly to the SPE classification scheme in which E-type programs, in particular, are defined as programs that implement applications or solve problems from and in the real world. In developing this schema process models played a fundamental role [LEH80b]. These models had no direct or immediate relationship to development practice but, nevertheless, led to the insight that is reflected in the LST process model [LEH84] that later formed the conceptual underpinning of a working environment [LEH85b].The work led to the view that an E-Type program is a model of a model of a … model of an application in the real world [LEH80b]. This abstract total-process model was enriched by Turski's view [TUR81] which regarded successive model pairs as a theory and a model of that theory or, equally, as a specification and an implementation of that specification. At the First Process Workshop [SPW84] Turski's interpretation of the “three-legged” model was, in fact, to see both the real world application (concept) and the final implementation as models of a specification that forms the bridge between concept and realisation. Equally, the source and target representations at the core of each step of the LST process, for example, may be viewed as a theory and a model of that theory.From Turski's view it follows that each implementation is Godel incomplete. Its properties, including functional properties, cannot be completely known from within the system. By their involvement in the development process and through system usage humans become an integral part of the system. It is their insights, viewpoints, theories, algorithms, definitions, formalisations, reactions, interpretations and so on that drive and direct the abstraction, refinement and evolution processes. They determine the degree of satisfaction that the final solution system yields. Hence it may be observed that for any software system implementing a solution to a real world problem, modelling some aspect of the real world, there exists a degree of Godel-type uncertainty about its properties [LEH89]. The definition, specification and development process must seek to limit this uncertainty so that it is of no practical significance; reflecting only abstract representational incompleteness.This is not the only type of uncertainty related to program behaviour under execution relative to the operational environment. A primary property of E-type programs is the fact that installation and operation of a system change the application and its operational domain. Implicitly if not explicitly, the system includes a model of itself. Also the acts of conceiving, developing, installing, using and adapting a software system change understanding of the application and its needs, methods of solution, the relative value of specific features of system functionality, opportunities for enhancement and human perception of all these. This leads to declining satisfaction with the system unless the system is adapted to the new reality. Because of the many feedback paths the system displays Heisenberg-type uncertainty [LEH77]. The more precise the knowledge of the application, of system properties and of their respective domains the less satisfaction does the solution system deliver in terms of what are, at the time of usage, the system properties perceived to be desirable. Mismatch between system properties and human needs and desires cannot be removed, except momentarily. Development, adaptation and evolution processes and their management are key to minimisation of the consequences of this inherent uncertainty.There is also a third type of uncertainty. The domain of an E-type application is, in general, unbounded and, effectively, continuous. The solution system is finite and discrete. The process of deriving one from the other involves a variety of abstractions on the basis of assumptions, about the application, its domain, perceived needs and opportunities, human responses to real world and solution system events, computational algorithms, theories about all these and so on. Some assumptions will be explicitly stated, others will be implicit. All will be built into the final system. But the real world is essentially dynamic, forever changing. Even without feedback effects as discussed above, exogenous changes in the real world will change the facts on which the assumption set is based. However careful and complete the control on the validity of assumptions is at the time they are built into the system some, at least, will, at best, be less than fully valid when the program is executed, or better, when the results of execution are applied. That is when, to be fully satisfactory, a program needs to be correct. Initial correctness at the time of implementation is merely a means to an end. The assumption set must be maintained correct without significant delay by appropriate changes to program or documentation texts, an impossible task even if assumptions could be precisely pinpointed. Pragmatic uncertainty in system behaviour is inevitable.This analysis leads to the following Uncertainty Principle for Computer Application: The outcome of software system operation in the real world is inherently uncertain with the precise area of uncertainty also not knowable.This position paper is not the place to explore this assertion in detail. Some aspects have been discussed elsewhere [LEH77, 89]. More immediately the principle throws a new light on the expectations to be associated with Software Engineering, the system and software development process and the models constructed to represent that process. One may have many views of the process. The new one that emerges from the above discussion is of software engineering in general and the software development and evolution (maintenance) process in particular as the means to minimise uncertainty, the consequences of uncertainty and the maintenance of user satisfaction. Project models must reflect this responsibility
Read moreSoftware process modeling: a behavioral approach
Recently, the software engineering community has focused its attention on the process of software creation and evolution as well as the products of that process. Much of this attention has concentrated on modeling the software process. Software process models are seen as important vehicles for understanding and reasoning about software creation and evolution activities. Software process models may also provide a basis for structuring automated software environments. Despite this attention and the advantages to be gained through the use of software process models, however, no wholly satisfactory model of the software process has yet emerged.This paper presents an approach to software process modeling which is based on behavioral descriptions of software development activities. The use of behavioral descriptions makes it possible to describe the software process at any desired level of abstraction and, therefore, assists in accommodating aspects of the process which are poorly understood. This approach also provides the ability to reason about the software process and is sufficiently rigorous to provide a basis for structuring automated software environments. An overview of the model is presented, followed by a formal definition. Examples are given to illustrate the application of the model to existing software processes and software methods. Finally, the implications of the model for automated software environments are discussed.
Read more