Process-centered Software Engineering Environment Research Articles

A Knowledge-based PSEE with the Ability of Project Monitoring

Process-centered software engineering environments (PSEEs) facilitate managing software projects. According to the change of enactment environments and the increment of software development complexity, PSEE features should be enhanced. We designed a knowledge-based PSEE named KPSEE. It offers the features: (1) maximizing the degree of process parallelism, (2) enhancing process flexibility, (3) managing product consistency, (4) integrating PSEEs, (5) keeping pace with significant process change, (6) preventing technique leakage, and (7) offering project monitoring ability.

Supporting collaborative development using process models: a tooled integration‐focused approach

ABSTRACTCollaboration in software engineering projects is usually intensive and requires adequate support by well‐integrated tools. However, process‐centered software engineering environments (PSEE) have traditionally been designed to exploit integration facilities in other tools, while offering themselves little to no such facilities. This is in line with the vision of the PSEE as the central orchestrator of project support tools. We argue that this view has hindered the widespread adoption of process‐based collaboration support tools by incurring too much adoption and switching costs. We propose a new process‐based collaboration support architecture, backed by a process metamodel, that can easily be integrated with existing tools. The proposed architecture revolves around the central concepts of ‘deep links’ and ‘hooks’. Our approach is validated by analyzing a collection of open‐source projects, and integration utilities based on the implemented process model server have been developed. Copyright © 2014 John Wiley & Sons, Ltd.

Supporting model-driven development using a process-centered software engineering environment

The adoption of Model-Driven Development (MDD) is increasing and it is widely recognized as an important approach for building software systems. In addition to traditional development process models, an MDD process requires the selection of metamodels and mapping rules for the generation of the transformation chain which produces models and application code. In this context, software process tasks should be performed in a specific sequence, with the correct input artifacts to produce the output ones. However, existing support tools and transformation engines for MDD do not have a process-centered focus that addresses different kinds of software process activities, such as application modeling and testing to guide the developers. Furthermore, they do not enable process modeling nor the (semi) automated execution of activities during process enactment. The MoDErNE (Model Driven Process-Centered Software Engineering Environment) uses process-centered software engineering environment concepts to improve MDD process specification and enactment by using a metamodeling foundation. In MoDErNE, a software process model may be enacted several times in different software projects. This paper details the MoDErNE environment, its approach and architecture and also the case studies through which the tool was evaluated.

Process modelling, delegation and control in global software development

Owing to globalisation, it became necessary for software companies to take advantage of computing skills distributed worldwide. One of the resulting problems is the difficulty to model tasks to be assigned remotely. We know how to explicitly define tasks and working methods using process technologies; thus, processes and their artefacts become important factors to be considered. This paper proposes a new approach of process modelling for its remote performance. The main advantage of this approach is to maintain collaboration among autonomous Process-centred Software Engineering Environments (PSEEs) during process performance. An implementation and discussion are proposed to validate the work.

Uncertainty management in a process environment

Software systems are developed by software projects. A software project generally associates with a process (software development process). A software project's process can be managed by process‐centered software engineering environments (PSEEs). In other words, PSEEs facilitate monitoring software projects. When a software project is being executed, many details may be uncertain in the early phases of the project. Therefore, managing uncertainty of a project's process becomes necessary. We identified existing approaches that can manage process uncertainty. Nevertheless, existing approaches suffer from drawbacks such as resource wasting. We thus propose two new approaches, which are pre‐defined semantics and incremental process program development. The former approach prevents duplicating the same code in a process program and the latter handles both predictable and unpredictable process uncertainty. This paper primarily presents the new approaches.

An information flow control model for software processes that manages developer associations

A software process (software development process) should be followed to develop software. As agreed, process‐centered software engineering environments (PSEEs) facilitate controlling complicated software processes. Quite a few issues regarding PSEE such as process evolution support have been addressed. Nevertheless, PSEE researchers have generally ignored the important issues of ensuring secure product access during process execution. This can be achieved through information flow control. This paper proposes an information flow control model to ensure secure product access. The model also manages developer associations and adapts to developer association change.

ADPE: Agent-Based Decentralized Process Engine

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 to This paper presents ADPE.

Secure Access of Products in a Process Environment

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.

DPE/PAC: decentralized process engine with product access control

This paper proposes a process engine called DPE/PAC (decentralized process engine with product access control). It can be embedded in a PSEE (process-centered software engineering environment) to decentralize the PSEE. In a decentralized PSEE, every site can enact process programs and therefore the workload of the PSEE’s sites is balanced (i.e., no site will become a bottleneck). Moreover, when a site is down, other sites can enact process programs. Therefore, a decentralized PSEE overcomes the following drawbacks of a traditional client/server PSEEs: (a) the server may become a bottleneck and (b) when the server is down, the entire process should be suspended. In addition to decentralizing PSEEs, DPE/PAC offers an additional function, which is ensuring secure product access (including the enforcement of separation-of-duty constraints). The function is essential for a software process that develops sensitive software systems.

DPEM: a decentralized software process enactment model

This paper proposes a decentralized process enactment model called DPEM, which operates on the network. It consists of multiple developer sites, a name server site, a developer coordinator site, and an event manager site. DPEM also provides an intermediate process language called DPEL. To enact a process program written in a source process language (e.g. CSPL and APPL/A), the process program is first translated into DPEL segments, in which those for developer sites are composed of activities and synchronization information. Next, DPEL segments are transferred to DPEM sites. Then, activities in developer sites are enacted concurrently, during which activities are synchronized using synchronization information transferred to the developer sites. Major features offered by DPEM are: (1) every site in DPEM can enact DPEL segments and hence no site will become a bottleneck, (2) a software product is managed by the site that accesses it frequently, which reduces network flows, and (3) DPEM can coordinate heterogeneous process-centered software engineering environments using the intermediate process language DPEL.

ProActNet: MODELING PROCESSES THROUGH ACTIVITY NETWORKS

This paper proposes a process-centered software engineering environment (PSEE) called ProActNet (modeling processes through activity networks), which provides a process modeling language also called ProActNet. ProActNet pays special attention to handling human factors, including: 1) facilitating process program development, 2) allowing incremental process program development, 3) modeling abnormal conditions such as worker feedback, abnormally quitting activities, and abnormally canceling activities, and 4) modeling incremental product development. In addition to handling human factors, ProActNet also supports process change (evolution), which is essential in a PSEE. Moreover, ProActNet models processes as unordered, concurrent activities. With this, activity sequence, concurrency, and synchronization need not be specified in a process program, which simplifies process program development.

Process-Centered Software Engineering Environments, A Brief History and Future Challenges

Software engineering environments have a history of about two decades. Early environments provided support for small fragments of the software process (usually focusing on programming-in-the small). Then there was a trend towards support for more complete software processes (from early phases like requirements analysis and design down to testing and configuration management). Ten years ago the notion of process-centered software engineering environments initiated a new field in software engineering: software process research. The key idea is to use a model of a software process as input parameter for a software engineering environment. The environment is supposed to “behave” in accordance to the process model. Some aspects of this vision became true, others turned out to be of little practicability. In this article, we discuss the history of software engineering environments with a particular focus on process-centered software engineering environments (PCSEEs). We discuss the notion of distributed software processes (as one of the most substantial current trends in software process research) and we motivate the notion of a software process middleware which serves as basis of real-world software processes spread over various sites. In addition, we discuss some other trends in the software process research arena.

A Comparative Review of Process-Centered Software Engineering Environments

Process Centered Environments (PCEs) are the most recent generation of environments supporting the software engineering process. They aim to drive and assist developpers in the application of software development methods, by exploiting an explicit representation of the process. Several PCEs have been developped, both as research project and commercial products. This paper makes a point of research works and research challenges. It identifies 8 PCEs and a list of general requirements selected regarding actual software process technology needs along with some PCEs experiments results. A set of comparison criteria is then established and a list of open issues, derived from PCEs comparison, is presented.

Softev: UML-based PSEE environment

Software development processes, as a mean to ensure software quality and productivity, have been widely accepted within the software development community. This research introduces how to assist developers to establish quality management plan and monitor the implementation of software processes quantitatively in a CASE environment. A PSEE (process-centered software engineering environment) named Softev has been brought forward to provide developers the environment to define, execute and monitor their processes. As UML is becoming a standard diagrammatic notation for object-oriented modeling and is spreading rapidly, it has been chosen to express the artifacts developed during the requirement analysis and system design stages. In the early products of software process engineering, most research mainly focus on the representations of complex organizational processes and architectures for process-centered application support environment. However, the metrics of software processes and artifacts was not paid sufficient attention to. This research proposes the attributes to be measured during the development period which enable managers to predict and supervise the software project more precisely.

MAPS-15504 - Uma metodologia automatizada para avaliação de processo de software

The increasing demand for quality has led the software engineering community to produce several standards and norms to guide the quality of software products and processes. Amongst the process standards, the following may be highlighted due to their wide use: ISO 9000-3, ISO 12207, CMM and ISO/IEC TR 15504. An additional important research result of the software engineering community is Process-centered software engineering environments (PSEE). These environments aim at providing integrated support for software process automation. This paper presents MAPS-15504, an automated methodology for evaluation of the quality of software processes based on the ISO/IEC TR 15504. MAPS-15504 was applied to a case study and implemented in the ExPSEE environment. ExPSEE is an experimental PSEE developed at the Department (DIN) of Informatics of the State University of Maringa (UEM)

Exception handling in workflow management systems

Fault tolerance is a key requirement in process support systems (PSS), a class of distributed computing middleware encompassing applications such as workflow management systems and process centered software engineering environments. A PSS controls the flow of work between programs and users in networked environments based on a metaprogram (the process). The resulting applications are characterized by a high degree of distribution and a high degree of heterogeneity (properties that make fault tolerance both highly desirable and difficult to achieve). We present a solution for implementing more reliable processes by using exception handling, as it is used in programming languages, and atomicity, as it is known from the transaction concept in database management systems. We describe the mechanism incorporating both transactions and exceptions and present a validation technique allowing to assess the correctness of process specifications.

Integração de características de groupware ao AIGLE - ambiente integrado de engenharia de software evolutivo

Cooperation reflects a change in the emphasis of the use of the computer to solve problems, migrating from an isolated vision to another that facilitates human interaction. It may be said that the objective of the groupware is to help groups in communication, collaboration and co-ordination of its activities. This research work studies the theoretical aspects of the groupware area and applies them to the prototype of a process-centered software engineering environment, AIGLE - Integrated Environment of Evolutive Software Engineering. The intention was to add functionalities to allow synchronous and asynchronous communication among people co-operating among themselves to achieve a result

Process evolution support in concurrent software process language environment

This article describes the process evolution support in concurrent software process language (CSPL) environment. Process evolution refers to dynamically changing process programs during process enactment. It is required in process-centered software engineering environment (PSEE) because: (1) parts of a software process may be unclear during process modeling, and (2) processes may change during enactment. In CSPL, process evolution can be achieved through (1) meta-process or (2) process program change. This article also describes object decomposition in CSPL, which relates to process evolution. CSPL allows decomposing large objects (software products) into sub-objects. With this, the schedule, budget, and developer of each sub-object development can be separately assigned and controlled.

Graph-Based Software Process Management

Software process dynamics challenge the capabilities of process-centered software engineering environments. Dynamic task nets represent evolving software processes by hierarchically organized nets of tasks which are connected by control, data, and feedback flows. Project managers operate on dynamic task nets in order to assess the current status of a project, trace its history, perform impact analysis, handle feedback, adapt the project plan to changed product structures, etc. Developers are supported through task agendas and provision of tools and documents. Chained tasks may be executed in parallel (simultaneous engineering), and cooperation is controlled through releases of document versions. Dynamic task nets are formally specified by a programmed graph rewriting system. Operations on task nets are specified declaratively by graph rewrite rules at a high level of abstraction. Furthermore, editing, analysis, and execution steps on a dynamic task net, which may be interleaved seamlessly, are described in a uniform formalism.

Assessing process-centered software engineering environments

Process-centered software engineering environments (PSEEs) are the most recent generation of environments supporting software development activities. They exploit an representation of the process (called the process model that specifies how to carry out software development activities, the roles and tasks of software developers, and how to use and control software development tools. A process model is therefore a vehicle to better understand and communicate the process. If it is expressed in a formal notation, it can be used to support a variety of activities such as process analysis, process simulation, and process enactment. PSEEs provide automatic support for these activities. They exploit languages based on different paradigms, such as Petri nets and rule-based systems. They include facilities to edit and analyze process models. By enacting the process model, a PSEE provides a variety of services, such as assistance for software developers, automation of routine tasks, invocation and control of software development tools, and enforcement of mandatory rules and practices. Several PSEEs have been developed, both as research projects and as commercial products. The initial deployment and exploitation of this technology have made it possible to produce a significant amount of experiences, comments, evaluations, and feedback. We still lack, however, consistent and comprehensive assessment methods that can be used to collect and organize this information. This article aims at contributing to the definition of such methods, by providing a systematic comparison grid and by accomplishing an initial evaluation of the state of the art in the field. This evaluation takes into account the systems that have been developed by the authors in the past five years, as well as the main characteristics of other well-known environments