sync rule that is used to synchronize all abstract transitions together can be defined as follow. For every L-fragment l ,⇒,⇒ ,⇒ ∈ , we have, Chapter 5. Facilitating Inter-Organizational Business Process Collaboration 128 ∃ , ∈ . \ , ⇒ ∗ ⇒⇒ ⟶ ∈ _ , ∧ ∈ _ , . Example 5.. In Figure 5. (a), we can see that AS-region contains two fragments and with sync rules and . When applying _ Π, ), we have abstract lifecycle of and abstract lifecycle of with abstract sync rule . In addition, Figure 5. (b) shows a case of sync abstraction for AS-region which contains multiple entry transitions and multiple exit transitions ASL-fragments (both ASL-fragments and ). Figure 5.: Examples of sync abstraction In the above example, we demonstrate the sync abstraction of two synchronized fragments. However, it is possible that an AS-region contains more than two ASLfragments. For wider understanding of sync abstraction, we illustrate a sync abstraction of more than two SL-fragments in Figure 5. (with artifact extended to the example in Figure 5. (b)). Example 5.. In Figure 5., we can see that AS-region contains synchronized fragments and of artifact and , respectively, and of artifact . As all three fragments can be considered as ASL-fragments in , we can validly apply function _ Π, ) and the abstract lifecycles of artifacts {A , A , A } with abstract sync rules {r , r } are returned. Chapter 5. Facilitating Inter-Organizational Business Process Collaboration 129 Figure 5.: Example of abstraction of more than two ASL-fragments Next, we discuss the case of an AS-region containing SL-fragments with a nested (sub) SL-fragment that synchronizes with other lifecycle. Intuitively, the sub SLfragment and its synchronized lifecycle should be also taken into account when its super fragment has to be abstracted. Therefore, we need to induce the abstraction to its sub fragment together with its counterpart if they both can satisfy the property of AS-region (which is considered as a sub AS-region of the whole). In other words, we can say that the entire AS-region should contain such counterpart in order to have a valid abstraction. We show an example of AS-region consisting of sub SL-fragment in Figure 5.. Figure 5.: Example of abstraction on nested sub-SL-fragment Example 5.. In Figure 5., we can see that L-fragment is a synchronized fragment of L-fragment which is nested under L-fragment . The abstraction Chapter 5. Facilitating Inter-Organizational Business Process Collaboration 130 yields abstract transitions with abstract sync rule that is in the lifecycle of A and in the lifecycle of A . Next, we show that sync abstraction function _ preserves the B-consistency of between two synchronized lifecycles of the input and two outputted abstract lifecycles. THEOREM 5. (SYNCHRONIZED FRAGMENTS B-CONSISTENT ABSTRACTION). Let , be an AS-region in ACP model Π that is to be abstracted in ACP model Π and let be a set of abstract artifact lifecycles resulted from applying sync abstraction function _ Π, . Then the following statement holds. ∀ , ∈ |l ≺ ∧ l ∈ , ∃ , ∈ ,

ion built in (Price’s [116] “[e]ncapsulate complex behavior within a component” or their use of function labels to simplify the output; Iwasaki et al.’s [78] model fragments), but their simulations and thus verifications produce results for the entire model in one chunk or otherwise, like with [78], are producing output for a specific aspect of themodel. Simulation enables individual verifications to stay focused on one function or one behavior at a time even if the functional decomposition is very large while not requiring that a user scope the verification themselves. This automatic focusing should make results to handle compared to those that produce output for the entire model. Additionally, DESC is a step towards the “[m]ulti-level modelling” mentioned by Price et al. [117] as necessary to achieve future targets for qualitative reasoning. Second, DESC leverages the same causal process representation (state diagrams, a.k.a., behaviors) in SBF* for both reasoning and representing simulation results, whereas other work uses representations for reasoning (e.g., component models or model fragments) that differ from the state-based representations in their simulation results. From the perspective of SBF* modeling, DESC thus does not require modelers to learn a new representation for reasoning since it leverages aspects of the models that are already part of the SBF* models being built–with the exceptions that modelers will need to learn equation syntax and simulation semantics (although the latter should be generally intuitive relative to modeling expectations). Additionally, that the verification results are couched in terms of the alreadymodeled elements (i.e., as issues in state conditions and function provides conditions) should lessen the cognitive burden relative to other systems because users do not need to learn a second representation to interpret the results as they would if one built a component model and then interpreted state-based representation results. DESC also differs from [78, 116] by incorporating functions into the simulation. They impact the simulation process by acting as pointers to subbehaviors rather than just being used in evaluation/output. This empowers the simulator to use existing structural aspects of the model (i.e., the functional decomposition) in its reasoning, which should also, in the

Within the development of partnership and sub-contracting activities, collaborative design and data management processes are crucial for faster and better product development. Collaborative environments and integrated design are now deeply linked with product development activities. These practices are used to combine the strength, expertise and know-how of the best diverse, geographically dispersed technical teams to reach better mission scenarios, designs, and to develop corresponding technologies in less time [16]. This paper deals with the work done within the 6th framework project called VIVACE (Value Improvement through a Virtual Aeronautical Collaborative Enterprise) which involves most of the large aeronautic enterprises in Europe. The approach used by the Engineering Data Management Work Package of this project is motivated by the fact that data is not still well integrated and interoperable between partners’ systems. This paper focuses on the definition of interoperable environments and definition of context for use. In this paper, we develop the concepts reached during the VIVACE project. We present first a collaborative typology that is helpful to better understand constraints while partners attempt to collaborate. We then expose our guidelines for collaborative environment development by using the definition of a multi-layered architecture. We finally develop the components of this architecture and propose the definition of a scenario based on design/simulation loop.

With the increasing emergence of technologies that make use of the Internet, the need for methodologies that would help the development of applications for the web emerged. Researchers and developers in order to meet this lack proposed methodologies based on Software Engineering, creating a subarea of it, called web engineering. This work aims to compare two of these methods, known as UWE (UML Web Engineering) and OOWS (Object Oriented Web Solution). They define their own notation for modeling, which often run the same concepts. The study was conducted under a qualitative approach, seeking information through educational materials analysis, systematic review articles and monographs, which were starting tool for the study of comparative case method. Thus it was found, by building a navigational model, which methods have very similar concepts, being differentiated on how these concepts are represented. It was also found that the UWE method is more concerned with the structure of modeling, while the OOWS method prioritizes the functional system requirements.

Web development teams include not only software engineers but also graphic designers. In this work, we extend the OOWS method in order to introduce graphic designers into its development process. To do this, we extend the automatic code generation strategy of the OOWS method to obtain code that provides users with the information and functionality captured in the requirements model but without considering any kind of aesthetic aspect. We also propose a strategy to define domain-independent presentation templates. These templates can be applied to any web application developed by the OOWS method. These extensions allow us to define a web development process where graphic designers work together with analysts with a high degree of independence from each other but always in a coordinated way.

Web applications are evolving towards an inter-organizational environment where new requirements arise (application integration by means of the composition of different enterprise business processes) and where these requirements need to be faced within the application development process. In this work we propose an extension to the OOWS Web Engineering method for the development of Web applications based on business processes. In this extension we have taken into account both the existence of manual tasks carried out by human participants and the fact that processes within a B2B context usually involve the use of distributed functionality, which is normally provided by means of Web Services. Moreover, the use of model transformation techniques (such as the standard QVT) allows us to obtain from business process specifications both (1) the graphical user interfaces that allow the execution of these processes and (2) the executable specification of the process defined in WS-BPEL.

Web Service (WS) developers must take several decisions to design Service Oriented Architectures. Some of these decisions are: which operations should provide the involved Web Service, how we can detect these operations, in which way this can be automated and which is the right granularity of the operations. To address some of these questions, we present in this paper a methodological approach that extends the OOWS web engineering method. Following a model-driven approach, we systematically identify and design the operations of a Web service, taking as the source: (1) the tasks that the user must be able to achieve and (2) the OOWS conceptual models.

Web Engineering (WE) methods have evolved to support different concerns during the development process of current Web-based systems, as context-awareness, Business-to- Business (B2B) process modeling, Rich Internet Applications (RIAs) and live-regions or quality factors to improve users' experience. Therefore, developers have conceptual tools to focus on these concerns in advance, but unfortunately, the situation is not the same to early accessibility design. In this paper we provide a briefly overview of our proposal, called Aspect-Oriented Web Accessibility Design (AO-WAD), and generalize its use within some of the best known WE approaches to provide accessibility support through Aspect- Orientation techniques. We embed AO-WAD into OOHDM, UWE and OOWS methods and propitiate an ease understanding through a motivating example.

We present the generator framework WASL, which supports mod el-driven development of web applications. It enables the modeling of data, navigation, business logic, a nd presentation logic. WASL supports the MDA by providing transformation definitions from a computation-i ndependent model (CIM) to a platform-independent model (PIM) and then to a platform-specific model (PSM). An im portant aspect of our approach is that we provide a separate DSL for each target platform in order to se parate concerns between PIM and PSM and to be able to address platform-specific aspects. Currently, th e frequently used platforms Java, PHP, and Python

We present a novel model-driven methodology for developing secure data-management applications. System developers proceed by modeling three different views of the desired application: its data model, security model, and GUI model. These models formalize respectively the application's data domain, authorization policy, and its graphical interface together with the application's behavior. Afterwards a model-transformation function lifts the policy specified by the security model to the GUI model. This allows a separation of concerns where behavior and security are specified separately, and subsequently combined to generate a security-aware GUI model. Finally, a code generator generates a multi-tier application, along with all support for access control, from the security-aware GUI model. We report on applications built using our approach and the associated tool.

We analyze how the semantics of association relationships in OO conceptual modeling can help to build navigational models for Web applications. The work has been developed in the context of OOWS (a model-driven development method for building Web applications). We study some structural and behavioral properties of those conceptual abstractions in order to extract knowledge to be applied in the construction of navigational models. From this study, a set of design rules has been obtained. These rules help the modeler to build navigational models in a systematic way. The results of this work have improved the modeling and code generation processes introduced by OOWS.

Using UML class diagrams or OWL specifications, the designer is always confronted with the same problem: which concept should be modelled as a class and which concept can be pruned to an attribute (DatatypeProperty)? In this paper, a very simple and easy methodology to derive classes and attributes from a network of concepts will be introduced. Using this methodology, the designer will be even able to start modelling with controlled English language patterns. At the end, a prototype implementation will show how they all fit together.

Usability plays an important role to satisfy users' needs. There are many recommendations in the HCI literature on how to improve software usability. Our research focuses on such recommendations that affect the system architecture rather than just the interface. However, improving software usability in aspects that affect architecture increases the analyst's workload and development complexity. This paper proposes a solution based on model-driven development. We propose representing functional usability mechanisms abstractly by means of conceptual primitives. The analyst will use these primitives to incorporate functional usability features at the early stages of the development process. Following the model-driven development paradigm, these features are then automatically transformed into subsequent steps of development, a practice that is hidden from the analyst.

Usability is a feature of software quality that has traditional significance in the Human Computer Interaction (HCI) community. Recent works that have been proposed by the Software Engineering (SE) community are intended to improve the usability of software applications. This paper combines aspects that are defined in both these communities to produce usable web applications. To achieve this goal, a well-known strategy to improve usability is used: usability patterns. However, many usability patterns and guidelines could only be applied when the final system is implemented. In this work, STATUS patterns have been chosen because they solve usability issues at conceptual level. The main purpose of this paper is to improve the usability of Web Applications automatically generated by OOWS (a model-based web engineering method) applying the STATUS patterns.

Traditionally, the Software Engineering community has been interested in defining methods and processes to develop software by specifying its data and behavior disregarding user interaction. On the other hand, the Human-Computer Interaction community has defined techniques oriented to the modeling of the interaction between the user and the system, proposing a user-oriented software construction. This paper aspires to reconcile both visions by integrating them in a whole software production process. An approach based on conceptual-schema centric software development is presented, where conceptual primitives intended to specify static, dynamic and interaction aspects are properly provided. Furthermore, Model Transformation techniques are proposed to go from the problem space, represented by the Conceptual Schema, to the solution space, represented by the corresponding final software product. This proposal is underpinned by some current MDA-based technology, which makes user-oriented, model-based software generation a reality

Traditionally, the Conceptual Modelling (CM) community has been interested in defining methods to model Information Systems by specifying their data and behaviour, disregarding user interaction. On the other hand, the Human-Computer Interaction (HCI) community has defined techniques oriented to the modelling of the interaction between the user and the system, proposing a user-centred software construction, but leaving out details on system data and behaviour. This paper aspires to reconcile both visions by integrating task modelling techniques using a sound, conceptual model-based software development process in a HCI context. The system is considered on its three axis (data, functionality and interaction), as a whole. The use of CTT (Concurrent Task Trees) embedded in a model-based approach makes it possible to establish mapping rules between task structure patterns that describe interaction and the elements of the abstract interface model. By defining such structural patterns, the CTT notation is much more manageable and productive; therefore, this HCI technique can be easily integrated in a well-established conceptual modelling approach. This proposal is underpinned by the MDA-based technology OlivaNova Method Execution, which allows real automatic software generation, while still taking user interface into account at an early requirements elicitation stage.

Today, more and more Web sites and Applications (WebApps) are becoming mission-critical systems. Measures of functional size are a prerequisite to successful quantitative management of software projects. However, the nature of the web has recently imposed new and challenging characteristics, which are not supported by the existing estimation metric and models. In order to avoid the Web crisis, we urge the use of web engineering approaches for developing and estimating web projects in a systematic way. To achieve this goal, we present a novel size metric for accurately measuring the functional size of web applications early in the development life cycle. The main contribution of this work is the introduction of a measurement process that is embedded in the conceptual modelling phase of a model-driven approach for developing web applications. The results obtained from our experiments with this approach are outlined in this work.

This work presents an OO software production method that provides conceptual modelling extensions (in terms of models and abstraction primitives) to facilitate the web application specification and development process. It also discusses a strategy to automatically go from the problem space (conceptual models) to the solution space (final software product) in an automatic way, by implementing a set of mappings between conceptual primitives and their corresponding software representations. To include a practical view of the approach, the work describes a real case-study of a University Department Web System that has been developed with this method.

This work presents an OO software production method that defines a systematic process for conceptual modelling of web applications. The paper discusses a set of minimum primitives to capture the essentials of dynamic web applications and it discusses how to introduce them in a classical model-centered OO method that provides systematic code generation. Finally, the paper presents some ideas to extend this generation process for developing web solutions taking as an input these web enhanced conceptual schemas.

This work presents a code generation process that systematically obtains the implementation of the UML association, aggregation and composition concepts in the context of the OO-Method (an OO automated software production method). A multidimensional framework, which identifies a set of basic properties, allows us to characterize association relationships in the OO conceptual modelling. By applying this framework, we provide a particular interpretation of the UML association, aggregation and composition concepts for the OO-Method. Once we have defined a clear semantics for these concepts, we introduce a code generation strategy that obtains the implementation of these abstractions depending on the value of the framework dimensions. This strategy can be applied to current OO development methods in order to systematize the software production process in model-driven approaches.