The economics of software engineering [B. W. Boehm, Software Engineering Economics, Prentice-Hall, Englewood Cliffs, New Jersey, 1981] are strongly influenced by the way how software development processes are performed. Simulations give valuable insights in the performance of these processes. In order to research the economics of software engineering, a process analysis studio (PAS) was developed and presented [D. Kuhlen and A. Speck, Business process analysis by model checking, in Proc. 5th Int. Symp. Data-Driven Process Discovery and Analysis SIMPDA, eds. P. Ceravolo and S. Rinderle-Ma, 2015; D. Kuhlen and A. Speck, The way of designing a simulation software in order to evaluate the economic performance in software development, in ICCMS ’17 Proc. 8th Int. Conf. Computer Modeling and Simulation, Int. Conf. Proc. Series by ACM, 2016; D. Kuhlen, Kostensenkungspotenzialfunktion der Softwareproduktion, dissertation, Christian-Albrechts-Universität zu Kiel, 2019]. This simulation software was built to analyze the capacitive configurations of the software production. It helps to assess the impact of different configurations on the process output. However, this research emphasizes the impact of quality-related factors (QRFs) on the process output. This paper presents a proposal how to extend the simulation software model in order to facilitate qualitative analysis. In order to facilitate the understanding of the model and the evaluation of the contribution, offered by the proposal, Prolog codes are used.

The (improved) digitalization of economy and administration is a common major endeavor. In general digitalization looks quite simpe: the currently semi-automated business processes are to be formalized and based of these formal business process models highly automated systems are to be developed. One challenge is to formalize the informal knowledge of the stakeholders driving the processes. To optimize and document business processes, it is important that different stakeholders can form a common understanding of them. This understanding is formally expressed in modeling languages like BPMN (Business Process Model and Notation). However, misunderstandings and errors occur time and time again. This paper presents a novel approach, based on a three-dimensional representation of the process, which on the one hand maintains the clarity of the overall process, but also allows an improved representation of details. The stakeholders may play their roles in the processes with avatars, and these roles may be recorded as the base of a formal process model.

(Business) Process models are common artifacts in requirements engineering. The models can be enriched with plenty of (detailed) information and their at least semi formal character even enables model driven approaches or direct execution in workflow engines. Validity of process models is crucial. Manual checking is expensive and error-prone, especially for requirements that regard the content level (e.g. compliance). To enable automated checking, an adequate method for formal specification is necessary. We present the Business Application Modeler (BAM), which is a modeling and Validation & Verification tool that integrates modeling of processes and formal graphical validation rules. These rules can be automatically applied to process models. In particular, the modeler is supported by visualizations of checking results directly in the process models. Next to highlighting mechanisms this support includes recommendations for the correction of errors.

Automated checking concepts for business process models support human testers considerably by saving time. However, this new checking ability results in a comparatively large number of rules representing requirements. But without a comprehensible representation of the relations between the rules on the one hand its hard to keep track on the validated rules and on the other hand to correctly interpret the validation results. In this paper we propose an improvement for the automated validation of business process models by offering elements to create abstract rules and arranging these rules in hierarchies. Top-down and bottom-up testing are supported by stepwise activating (and validating) the rules starting from the top of the hierarchy (or bottom respectively). Moreover, the rule hierarchies may be reused when similar systems are to be validated by configuring a valid rule sub-set for the specific business process system.

Components have been introduced in order to support software reuse. Components are reusable building blocks for larger systems consisting of units (code pieces) and their construction plan. Technologies like COM+, .Net, CORBA JavaBeans and EJBs (or web services which may be considered as web-based components) have been developed to support the component concept. However, components still have the problem of both unavailable and unreliable documentation of their properties. Moreover, a lack of validation support concerning the components' or composed systems' behavior may be observed. In other words, there is a lot of knowledge about how to combine components technically but less experience to validate the interactions between the components.

The automated generation of systems (e.g. within model-driven development) is a considerable improvement of the software development. However, besides the automated generation the verification of these generated systems needs to be supported, too. By applying generators it is not necessarily guaranteed that the generation outcome is correct. Typical problems may be, firstly, the use of a wrong operator resulting in an erroneous generation (static aspects of the generation). Secondly, the interactions between the different generated system assets (snippets) of the generated outcome might be incorrect, since the snippets might be connected in a wrong sequence (dynamic aspect of the generation). Therefore, the hierarchical dependencies of the snippets which are the input of the generator as well as the dynamic behavior resulting from the generation have to be checked. We describe the hierarchy in a version model based on Boolean logic. The temporal behavior may be checked by model checkers. For the generation we apply our XOpT concept which provides domain-specific transformation operators on the XML representation. Besides the principles of the static and dynamic elements of our checking approach the paper presents the way to map program assets to the version model and to finite state automata which are the prerequisite for the checking. Though the proposed checking is presented at the code level the approach may be applied to different kinds of assets, e.g. also on the model level.

Abstract A widely used architecture for the development of software systems is the component‐based application framework. Such frameworks offer two mechanisms. First, they provide component integration and interoperability services which make it possible to extend the framework with various third‐party components. Second, they provide mechanisms to customize the integrated components to the specific needs of applications to be built using the framework. This paper describes an architectural pattern for designing such frameworks so that the appropriate mix of fixed and flexible elements can be integrated into architectures that maximize scalability and extensibility. The pattern is illustrated by frameworks developed for three different application domains: electronic design automation, scientific visualization and numerical simulation, and industrial control systems. Copyright © 2005 John Wiley & Sons, Ltd.