Software Process Engineering Metamodel Research Articles

Self-Service Cybersecurity Monitoring as Enabler for DevSecOps

Current IoT systems are highly distributed systems that integrate cloud , edge , and fog computing approaches depending on where intelligence and processing capabilities are allocated. This distribution and heterogeneity make development and deployment pipelines very complex and fragmented with multiple delivery endpoints above hardware. This fact prevents rapid development and makes the operation and monitoring of production systems a difficult and tedious task, including cybersecurity event monitoring. The DevSecOps can be defined as a cultural approach to improve and accelerate the delivery of business value by making dev/sec/ops teams’ collaboration effective. This paper focuses on self-service cybersecurity monitoring as an enabler to introduce security practices in a DevOps environment. To that end, we have defined and formalized an activity that supports ‘ Fast and Continuous Feedback from Ops to Dev ’ by providing a flexible monitoring infrastructure so that teams can configure their monitoring and alerting services according to their criteria ( you build, you run, and now you monitor ) to obtain fast and continuous feedback from the operation and thus, better anticipate problems when a production deployment is performed. This activity has been formalized using the Software & Systems Process Engineering Metamodel by OMG and its instantiation is described through a case study that shows the versioned and repeatable configuration of a cybersecurity monitoring infrastructure ( Monitoring as Code ) through virtualization and containerization technology. This self-service monitoring/alerting allows breaking silos between dev, ops, and sec teams by opening access to key security metrics, which enables a sharing culture and continuous improvement.

Towards Enacting a SPEM-based Test Process with Maturity Levels

Effective monitoring and testing during each step are essential for document verification in research and development (R&D) projects. In software development, proper testing is required to verify it carefully and constantly because of the invisibility features of software. However, not enough studies on test processes for R&D projects have been done. Thus, in this paper, we introduce a Test Maturity Model integration (TMMi)-based software field R&D test process that offers five integrity levels and makes the process compatible for different types of projects. The Software & Systems Process Engineering Metamodel (SPEM) is used widely in the software process-modeling context, but it lacks built-in enactment capabilities, so there is no tool or process engine that enables one to execute the process models described in SPEM. Business Process Model and Notation (BPMN)-based workflow engines can be a solution for process execution, but process models described in SPEM need to be converted to BPMN models. Thus, we propose an approach to support enactment of SPEM-based process models by converting them into business processes. We show the effectiveness of our approach through converting software R&D test processes specified in SPEM in a case study.

Promoting MBA in the rail sector by deriving process-related evidence via MDSafeCer

An EN 50129-compliant safety case should include process-related evidence in terms of quality as well as safety management. Potentially innovative engineering methods developed in academic settings could act as process-related evidence. However, to ease their acceptance within the rail industrial settings, the adequacy of these methods need to be justified. In this paper, we extend our previous work and we provide a broader justification including performance aspects aimed at showing that the entire MBA (Model-Based design methodology for Assessing performance and safety requirements of critical systems) is partly compliant with EN 50128. To do that, we tackle safety and performance process-related compliance as follows: we first manually check if MBA includes EN 50128-compliant process elements, then we model MBA in compliance with Software Process Engineering Meta-model 2.0, then, we derive process-based arguments from the MBA process model by using the MDSafeCer (Model Driven Safety Certification) method. By doing so, we provide a twofold contribution: we further validate MDSafeCer in the rail domain and we strengthen MBA.

SysPEM: Toward a consistent and unified system process engineering metamodel

Industrial companies evolve in a highly competitive environment, their performance depends on their time to market as well as the quality of their products. This situation calls for a delicate optimization of supply chain and manufacturing processes, as a guarantee of the quality of the final system. Due to the fact that these processes are heterogeneous and poly-disciplinary, there is an urgent need for a general consistent model for all systems engineering concepts. Such model has to achieve an equilibrium between covering all key concepts of systems engineering processes and providing a rich language to express the details of these concepts. In this paper, we propose a solution to this problem through defining and validating a system process engineering metamodel inspired from research advances on Software Process Engineering Metamodel and System Modeling Language. The scope of this solution exceeds the definition and description of processes by providing an orchestration mechanism based on aspect oriented programming, in order to animate the execution control and monitoring through non intrusive mechanisms.

A Knowledge-Based Perspective for Software Process Modeling

As the acquisition and sharing of knowledge form the backbone of the software development process, it is important to identify knowledge discrepancies between the process elements. Explicit representation of the knowledge components within a software process model can provide a means to expose these discrepancies. This paper presents an extension of the Software and System Process Engineering Metamodel (SPEM), to be used as a new knowledge modeling layer. The approach, which is based on ontologies for knowledge representation, constitutes an explicit method for representing knowledge within process models. A concept matching indicator shows the state of the process model in terms of the concept gaps for each task within the process. This indicator could lead to more informed decision making and better management of the associated risks, in terms of team competency, documentation quality, and the training required to mitigate them.

A method fragments approach to methodologies for engineering self-organizing systems

This article summarizes five relevant methods for developing self-organizing multiagent systems. It identifies their most relevant aspects and provides a description of each one under the form of method fragments expressed using SPEM (Software and System Process Engineering Metamodel). The use of a “metamodel” to describe fragments facilitates the comparison of the methods and their respective fragments. These fragments can be combined and be part of a more general ad hoc methodology, created according to the needs of the designer. Self-organizing traffic lights controllers and self-organizing displays are chosen as case studies to illustrate the methods and to underline which fragments are important for self-organizing systems. Finally, we illustrate how to augment PASSI2, an agent-based methodology which does not consider self-organization aspects, with some of the identified fragments for self-organization.

XSPIDER_ML: Proposal of a Software Processes Enactment Language Compliant with SPEM 2.0

SPEM (Software Process Engineering Metamodel Specification) is the software processes modeling standard defined by OMG (Object Management Group). However, the process enactment support provided by this standard has many deficiencies. Therefore, the main objective of this paper is to propose a language for software process enactment based upon SPEM 2.0 concepts. First, we will present a critical analysis of the SPEM standard approach for enactment. Then, we will present xSPIDER_ML, an enactment language, and describe its structure, components and associated rules. In order to evaluate the proposed language, a case study is performed through a RUP (Rational Unified Process) process instantiation. The language presented in this paper is part of a support set of tools for flexible software process enactment. Additionally, this set of tools is in compliance with software process quality models.

SysPEM: a SysML and SPEM based process modelling language for systems engineering

The evolution of industry through a competitive environment resulted in a need for optimising the manufacturing processes. Many studies focalised on this topic, especially in the case of software engineering processes, which led to the definition of a standard for development processes (SPEM) by the OMG (Object Management Group) and a race to implement it through different languages and meta-models. Even if there is a huge similarity between software engineering and systems engineering, the standard and its different implementations are still insufficient to fulfil the requirements expressed through systems engineering standards such as EIA 632. In this paper a meta-model keeps the fruitful approach of the Software Process Engineering Meta-model (SPEM) combined with some useful concepts from the System Modelling Language (SysML). This model was validated through some predefined criteria, the specification of the EIA 632 standard and a sample process for systems engineering.

A Comparative Analysis between BPMN and SPEM Modeling Standards in the Software Processes Context

The main objective of this paper is to analyze the representativeness of the SPEM (Software Process Engineering Metamodel Specification) and the BPMN (Business Process Modeling Notation) standards in the software processes modeling context. To perform this analysis, it was adopted a standard structure to define a software process based upon a process ontology. Then, the SPEM and BPMN standards notations and their semantically corresponding elements in the default process were identified. This mapping also includes components of the CMMI-DEV (Capability Maturity Model Integration for Development) and MR-MPS (Reference Model for Software Process Improvement) quality models. This was necessary to assist in the mapping evaluation through a case study which models the best practices of these quality models. Finally, we carried out an analysis of these standards through specific characteristics considered necessary to model and to represent software processes.

A personalization process for spatial data warehouse development

Spatial data warehouses (SDW) rely on extended multidimensional (MD) models in order to provide decision makers with appropriate structures to intuitively explore spatial data by using different analysis techniques such as OLAP (On-Line Analytical Processing) or data mining. Current development approaches are focused on defining a unique and static Spatial multidimensional (SMD) schema at the conceptual level over which all decision makers fulfill their current spatial information needs. However, considering the required spatiality for each decision maker is likely to derive in a potentially misleading SMD schema (even if a departmental DW or data mart is being defined). Furthermore, spatial needs of each decision maker could change over time or depending on the context, thus requiring the SMD schema to be continuously updated with changes that can hamper decision making. Therefore, if a unique and static SMD schema is designed, acquiring the required spatial information is more costly than expected for decision makers and they may get frustrated during the analysis. To overcome these drawbacks, we argue for considering spatiality as a personalization feature within a formal design process. In this way, each decision maker will be able to access its own personalized SMD schema with its required spatial structures and instances, suitable to be properly analyzed at a glance. Our approach considers several novel artifacts: (i) a UML profile for spatial multidimensional modeling at the conceptual level, (ii) a spatial-aware user model in order to define decision maker profile; and (iii) a spatial personalization language to define spatial needs of decision makers as personalization rules. The definition of personalized SMD schemas by using these artifacts is formally defined using the Software Process Engineering Metamodel Specification (SPEM) standard. Finally, the applicability of our approach is shown through a running example based on our Eclipse-based tool for SDW development.

Modelling software process variability: an empirical study

Variability in software process models justifies tailoring them to meet the specific goals and characteristics of organisations and projects. Existing process modelling notations typically do not have constructs which are appropriate for expressing process variability. To fill this gap, the authors have extended software process engineering metamodel (SPEM) to vSPEM, by adding new variability constructs (such as variants and variation points). This article presents an empirical validation to check whether the variability constructs supported through vSPEM are more appropriate for modelling variant-rich processes than SPEM, in terms of understandability of the notation, as well as of their variability mechanisms. The results indicate that the vSPEM variability mechanisms understandability is a 126.99% higher than for SPEM. On the other hand, process diagram understandability is a 34.87% lower with vSPEM than with SPEM. If we compare the relative results obtained with regard to understandability of diagrams and understandability of variation mechanisms of both vSPEM and SPEM, the enhancement just mentioned is 3.64 times that fall. The results indicate accepting that a slight decrease in understandability of the diagrams might lead to a large increase in understandability when using variability mechanisms of vSPEM.

Transformations from SPEM work sequences to BPMN sequence flows for the automation of software development process

Generally, different companies use distinct software development process. Due to it, OMG has specified an architecture to can define a software development process. This architecture uses a metamodel which is able to be abstracted from particular characteristics and to give the possibility of defining the different software development processes. The Software Process Engineering Metamodel (SPEM) is a metamodel used for describing a concrete software development process. Also, the OMG specify a standardized language to model business processes. This language is called Business Process Modeling Notation (BPMN). In this paper, a formalization of transformations between SPEM and BPMN is specified. The transformations are done using the language of formal specification RSL. One time that we obtain a BPMN specification, it is possible to generate XPDL code or BPEL code. The workflow technology can use this code and execute the process. It allows automate the business process, but in this case, the process is a software development process. Consider that workflow technologies automate, totally or partially, the business processes enabling an interaction between men and machines, under an established set of procedural rules. Such technologies use standard languages, like BPEL or XPDL, to specify the business process which is executed in a workflow engine. The BPMN allows to generate BPEL or XPDL codes. Therefore, if we specify a software development process using SPEM, we will automate this process using the workflow technology due to transformations between SPEM and BPMN done in this paper.

MODELING AND ANALYSIS OF KNOWLEDGE FLOWS IN SOFTWARE PROCESSES THROUGH THE EXTENSION OF THE SOFTWARE PROCESS ENGINEERING METAMODEL

Knowledge is a key asset in software engineering. Facilitating access to the knowledge that software engineers require for the task at hand can therefore bring many benefits. To accomplish this, it is important to understand how knowledge flows through the organization, to identify problems that may hinder a suitable flow, and to define strategies with which to address them. Process modeling has proved to be a useful technique for analyzing knowledge flows. Traditional process modeling languages do not, however, provide primitives to explicitly represent the knowledge involved in the processes within the models. In this paper, we illustrate how the Software Process Engineering Metamodel (SPEM) can be adapted, to be used as a process modeling language for analyzing knowledge flows in software processes. We have extended SPEM to represent knowledge and its sources in process models in an explicit way. We also discuss the experiences obtained from using this extension in a software organization and the lesson we have learned from it.

An engineering process for developing Secure Data Warehouses

We present a new approach for the elicitation and development security requirements in the entire Data Warehouse (DWs) life cycle, which we have called a Secure Engineering process for DAta WArehouses (SEDAWA). Whilst many methods for the requirements analysis phase of the DWs have been proposed, the elicitation of security requirements as non-functional requirements has not received sufficient attention. Hence, in this paper we propose a methodology for the DW design based on Model Driven Architecture (MDA) and the standard Software Process Engineering Metamodel Specification (SPEM) from the Object Management Group (OMG). We define four phases comprising of several activities and steps, an d five disciplines which cover the whole DW design. Our methodology adapts the i ∗ framework to be used under MDA and the SPEM approaches in order to elicit and develop security requirements for DWs. The benefits of our proposal are shown through an example related to the management of the pharmacies consortium business.

Transformation in QVT of Software Development Process based on SPEM to Workflows

This work provides a solution to automate the software development processes specified by the software process engineering metamodel (SPEM). To achieve this automation, the software development activities specified in SPEM are transformed in a subprocess specification of the Business Process Modeling notation (BPMN) defined by object management group (OMG), this transformation is done by Relations language which belongs to Query/Views/ Transformations (QVT). The obtained BPMN subprocess definition is turned into a specification in a standard language to put in action the workflow processes, such as Business process execution language for Web services (BPEL4WS) o XML Process definition language (XPDL). Therefore, in this way, the specification for the language to be implemented will be the input to a Workflow engine. Not only is the automation of the transformation achieved by this specification, but also, and basically, the automation of any software development process specified by SPEM through its transformation into BPMN subprocesses.

Towards Software Process Enactment Based on the SPEM2XPDL Model Transformation

SPEM (software process engineering metamodel) is the standard metamodel put forward by OMG (object management group) and widely accepted in industry. However, its model enactment is still at the early stage. In this paper, software process is viewed as a specialization of the more general kind of process known as workflow. SPEM2XPDL is presented as a software process enactment approach based on the model transformation. The well-defined mapping rules from SPEM to XPDL (XML process definition language) metamodels are provided and the corresponding transformation algorithm and engine are developed. This approach is implemented in the SoftPM project. After transformed to XPDL format, the SPEM models are successfully enacted by Shark, a famous XPDL

Applying Software Metrics to evaluate Business Process Models


 
 
 In this paper, we define a set of metrics for the evaluation of conceptual models of business processes. The proposal supposes the adaptation and extension of the FMESP framework (Framework for the Modeling and Evaluation of Software Processes). This adaptation can be carried out thanks to the similarities that exist between both types of processes (software and business). FMESP includes a set of metrics, which provide the quantitative basis necessary to find out the maintainability of the software process models. This proposal has been used as the starting point in proposing a set of metrics for the evaluation of the complexity of business process models defined by BPMN (Business Process Modeling Notation). Moreover, the groups of metrics of FMESP have been extended. This is because the models of business processes represented in BPMN include quite a number of aspects of interest in this domain which are not considered in software processes modelled with SPEM (Software Process Engineering Metamodel).
 
 

THE GAIA2JADE PROCESS FOR MULTI-AGENT SYSTEMS DEVELOPMENT

In this paper we present the Gaia2JADE process concerning how one can implement a multi-agent system with the JADE framework using the Gaia methodology for analysis and design purposes. This process is particularly dedicated to the conversion of Gaia models to JADE code. It is described using the Software Process Engineering Metamodel (SPEM) and extends the one proposed by FIPA for describing the Gaia modeling process. Thus, it proposes to potential MAS developers a process that covers the full software development lifecycle. This work is based on the experience we have acquired by applying this process for implementing a real-word multi-agent system conceived for providing e-services to mobile users. With this paper, we share this experience with future multi-agent systems (MAS) developers, who would like to follow this process, taking into account several technical issues that emerged during the implementation phase, helping them to easily model and implement their systems.

A SPEM-Based Software Process Metamodel for CMM

In applications of CMM (capability maturity model for software), it is a sticking point to implement enforceable software process models, which reflect the characteristics of organizations and their software processes, by transforming CMM software process model. Model driven architecture (MDA) supports model transformation and can be used in CMM practices, but the first step is to build a software process metamodel for CMM. This paper presents a software process metamodel for CMM based on SPEM(software process engineering metamodel), named SPM-CMM. SPM-CMM provides abstract syntaxes and rule semantics for CMM software process, and also supports of modeling of CMM integration with UML CASE tools.

A comparison of four process metamodels and the creation of a new generic standard

Software development processes and methodologies to date have frequently been described purely textually. However, more recently, a number of metamodels have been constructed to both underpin and begin to formalize these methodologies. We have critically examined four of these: the Object Management Group's Software Process Engineering Metamodel (SPEM), the OPEN Process Framework (OPF), the OOSPICE metamodel for capability assessment and the LiveNet approach for computer-supported collaborative work (CSCW). Based on this analysis, a new, combined metamodel, named Standard Metamodel for Software Development Methodologies (SMSDM) has been constructed which supports not only process but also products and capability assessment in the contexts of both software development and CSCW. As a proof of concept we conclude with a partial example to show how the SMSDM metamodel (and by inference the other metamodels) are used in practice by creating a simple yet usable methodology.