During the execution of software systems, their execution data can be recorded. By fully exploiting these data, software practitioners can discover behavioral models describing the actual execution of the underlying software system. The recorded unstructured software execution data may be too complex, spanning over several days, etc. Applying existing discovery techniques results in spaghetti-like models with no clear structure and no valuable information for comprehension. Starting from the observation that a software system is composed of a set of logical components, Liu et al. propose to decompose the software behavior discovery problem into smaller independent ones by discovering a behavioral model per component in [1]. However, the effectiveness of the proposed approach is not fully evaluated and compared with existing approaches. In this paper, we evaluate the quality (in terms of understandability/complexity) of discovered component behavior models in a quantitative manner. Based on evaluation, we show that this approach can reduce the complexity of the discovered model and gives a better understanding.

Software engineering education at universities plays an increasingly important role as software quality is becoming essential in realizing a safe and dependable society. This paper proposes a practical state transition model (Practical-STM) based on the Organizational Expectancy Model for the improvement of software process education based on the Personal Software Process (PSP) from a motivation point of view. The Practical-STM treats an individual trainee of the PSP course as a state machine, and formalizes a motivation process of a trainee using a set of states represented by factors regarding motivation and a set of operations carried out by course instructors. The state transition function of this model represents the features or characteristics of a trainee in terms of motivation. The model allows a formal description of the states of a trainee in terms of motivation and the educational actions of the instructors in the PSP course. The instructors are able to decide effective and efficient actions to take toward the trainees objectively by presuming a state and a state transition function of the trainees formally. Typical patterns of state transitions from an initial state to a final state, which is called a scenario, are useful for inferring possible transitions of a trainee and taking proactive operations from a motivation point of view. Therefore, the model is useful not only for improving the educational effect of the PSP course, but also for the standardization of the course management and the quality management of the instructors.

This paper customizes Goal/Question/Metric (GQM) project monitoring models for various projects and organizations to take advantage of the data from the software tool EPM and to allow the tailoring of the interpretation models based upon the context and success criteria for each project and organization. The basic idea is to build less concrete models that do not include explicit baseline values to interpret metrics values. Instead, we add hypothesis and interpretation layers to the models to help people of different projects make decisions in their own context. We applied the models to two industrial projects, and found that our less concrete models could successfully identify typical problems in software projects.

Software processes and corresponding models are dynamic entities that are often changed and evolved by skillful knowledge workers such as the members of a software development team. Consequently, process flexibility has been identified as one of the most important features that should be supported by both Process Modelling Languages (PMLs) and software tools that manage the processes. However, in the everyday practice, most software team members do not want total flexibility. They rather prefer to have controlled flexibility, i.e., to learn and follow advices previously modelled by a process engineer on which and how they can change the elements that compose a software process. Since process models constitute a preferred vehicle for sharing and communicating knowledge on software processes, the process engineer needs a PML that can express this controlled flexibility, along with other process perspectives. To achieve this enhanced PML, we first need a sound core set of concepts and relationships that defines the knowledge domain associated with the modelling of controlled flexibility. In this paper we capture and represent this domain by using Concept Maps (Cmaps). These include diagrams and descriptions that elicit the relationships between the concepts involved. The proposed Cmaps can then be used as input to extend a PML with modelling constructs to express controlled flexibility within software processes. Process engineers can use these constructs to define, in a process model, advices on changes that can be made to the model itself or to related instances. Software team members can then consult this controlled flexibility information within the process models and perform changes accordingly.

Web services (WS, hereafter) paradigm has attained such a relevance in both the academic and the industry world that the vision of the Internet has evolved from being considered as a mere repository of data to become the underlying infrastructure on which organizations' strategic business operations are being deployed [1]. Security is a key aspect if WS are to be generally accepted and adopted. In fact, over the past years, the most important consortiums of the Internet, like IETF, W3C or OASIS, have produced a huge number of WS-based security standards. Despite this spectacular growth, a development process that facilitates the systematic integration of security into all subprocesses of WS-based software development life-cycle does not exist. Eventually, this process should guide WS-based software developers in the specification of WS-based security requirements, the design of WS-based security architectures, and the deployment of the most suitable WS security standards. In this article, we will briefly present a process of this type, named PWSSec (Process for Web Services Security), and the artifacts used during the elicitation activity, which belongs to the subprocess WSSecReq aimed at producing a WS-based security requirement specification.

Tailoring industrial standards is done to reduce costs and improve quality for a particular project. This paper proposes using Bayesian Belief Network (BBN) analysis to support tailoring decision-making under uncertainties. However, there are two major problems associated with the objectivity of BBNs; that is, the construction of the causal inference diagrams and the assignment of probabilities of their dependency relations. We have developed a method to solve the first problem. In general, the relations among different activities, resources, and products addressed in software standards can be expressed more directly in Unified Modeling Language (UML) diagrams than in BBN's. Such relations include association, aggregation, or inheritance relations. We have developed a schema to construct BBNs for process tailoring from given UML diagrams that model a particular standard. The proposed approach systematically constructing BBNs can also be used to assist decision-making in other software project management activities, such as planning and risk management.

We introduce a method, so called FC method, for maintaining software resources, such as source codes and design documents, in consumer electronics products. Because a consumer electronics product is frequently and rapidly revised, software components in such product are also revised in the same way. However, it is not so easy for software engineers to follow the revision of the product because requirements changes for the product, including the changes of its functionalities and its hardware components, are largely independent of the structure of current software resources. FC method lets software engineers to restructure software resources, especially design documents, stepwise so as to follow the requirements changes for the product easily. We report an application of this method in our company to validate it. From the application, we can confirm that the quality of software was improved about in twice, and that efficiency of development process was also improved over four times.

Process-centered software engineering environments (PSEEs) facilitate controlling complicated software processes. Traditional PSEEs are generally centrally controlled, which may result in the following drawbacks: (1) the server may become a bottleneck and (2) when the server is down, processes need to be suspended. To overcome the drawbacks, we developed a decentralized process engine ADPE (agent-based decentralized process engine). ADPE can be embedded in any PSEE to decentralize the PSEE. This paper presents ADPE.

Process-centered software engineering environments (PSEEs) facilitate controlling software processes. Many issues related to PSEEs such as process evolution support have been addressed. We identify an unsolved issue, which is preventing information leakage when the process is being enacted. We developed a model called PsACL for the prevention. This paper proposes PsACL, which offers the following features: (a) controlling both read and write access of software products, (b) preventing indirect information leakage, (c) managing role associations, (d) managing role hierarchies, (e) enforcing static and simple dynamic separation-of-duty constraints, (f) allowing declassification of products, and (g) allowing access control information exchange among software processes.

This paper presents a model called PECM (process environment coordination model) to coordinate heterogeneous PSEEs. A PSEE coordinated by PECM is associated with a standard-interfaced PECM coordinator, which provides primitive coordination functions. PECM uses shared product status to coordinate PSEEs. It is expected to offer several features. First, multiple PSEEs can be used in the same project. Second, PECM manages products and product relationships across PSEEs. Third, PECM coordinator is standard- interfaced, which is easy to use.

The Capability Maturity Model (CMM) proposed by the Software Engineering Institute (SEI) of Carnegie Mellon University (CMU) is an effective framework for software process improvement (SPI) because it can increase development productivity and improve software quality for many software development companies. However, the CMM only indicates 'what' needs to be improved, it does not indicate 'how to' perform software process improvement activities (SPIA). In this paper we describe a Software Process Improvement support System (SPIS) that does indicate 'how to' perform SPIA. It is designed to be used mainly for internal SPIA by software development companies and their project teams. The SPIS is composed of seven support tools and promotes SPIA. The tools include a specific capability maturity model (SCMM), rules for assessing a company's maturity level, and an assessor qualification system for organizing the assessment team. These tools were extracted deductively from our experience and have proved to be effective when used for the SPIA at our company. (R): CMM is registered trademarks in the U. S. Patent and Trademark Office. SM: CMM is a service mark of Carnegie Mellon University.

In order to lead an ongoing software project to success, it is important to flexibly control its dynamically-changing software process. However, it is generally impossible not only to exactly pre-define the production process but also to prescribe the process change process (meta-process). To solve the problem, we have focused on communication between the project staff through which process change requests presented by individuals can be immediately shared, designed, verified, validated and implemented. This paper proposes a communication model which can represent a wide variety of communication states between the project manager and developers discussing how to implement process change requests. The communication model has been derived by investigating the sort of process change requests and, based on the model, we have implemented a cooperative process planning system (called CooPs). CooPs is a communication environment designed for software projects and supports information sharing for discussing the process change requests. By using CooPs, the software project can flexibly deal with not only expected change requests but also unexpected ones. To evaluate the applicability of the communication model and the capabilities of CooPs, we have conducted an experiment which is an application of CooPs to the ISPW6 example problem. This paper describes the concepts of CooPs, the system implementation, and the experiment.

In order to build up a process-centered software engineering environment using ontologies, we present a methodology to manually construct the following ontologies: an object ontology constructed based on constituent elements to make up objects (products), and a process ontology constructed based on the relationships between inputs and outputs. Afterwards, using the constructed ontologies, the environment generates software process plans good for user queries, with both user interaction and constraints satisfaction by the Generate and Test paradigm. Furthermore, case studies show us that the environment works well in generating software process plans good for a query about the intermediate stage of development, between basic design and detailed design.

Workers involved in software projects are unlike those working on a production line in a manufacturing field usually engaged in plural work (that is, not only main development work but also various other work), concurrently. Such other work might put pressure on the schedule of the whole project. Therefore, to manage the whole project, not only main development work but also various other work should be dealt with as management objects and workers' workload should be taken into consideration (that is, who is doing what work at what workload at what time). This paper proposes a framework for workload management facilities for managing software projects. This framework proposes to relate not only main development work but also various other work and each work step within cooperative work to the workers. This paper also shows the behavior of the facilities by using an example and shows its usefulness based on the application of a prototype system. Using this system, users can assign work to workers by simulating workers' workload. These facilities help managers grasp workers' workload as well as help workers grasp their assigned work.

Marc Kellner proposed an example problem intending to compare modeling and describing techniques of software process. In this paper, we will describe our approach to understanding and describing the problem, from a process/product relation view, and synchronization/concurrent view. Also, we will show that a description of the problem is translated for execution and its correctness is validated.