Search

Domain-specific modeling languages abstractly represent domain knowledge in a way that users can more easily understand the model content without technical expertise. These languages can be created for any domain, provided the necessary knowledge is available. This research uses educational game design as a demonstration of the power of domain-specific modeling. Games are useful tools in supplementing the traditional education of students, however, many educators often do not possess the design or technical skills to develop a custom game for their own use. MOLEGA (the Modeling Language for Educational Card Games) is a domain-specific modeling language that provides a guided model design environment for these users. Using MOLEGA, users can create visual models, inspired by UML class diagrams, to represent their desired card game, based on two selected variants. User models are then used to generate executable source code for a mobile-compatible, browser-based game that can be deployed on a server by following the provided instructions. MOLEGA is evaluated for validity and correctness using a suite of example models.

In general, college students enrolled in computer science courses are provided some software design classes and exercises. In a cross-reviewing learning/exercise environment, however, beginners often cannot provide useful feedback and viewpoints to others. One of the reasons for this is that beginners are not confident in their understanding of the software design models. These learners should be encouraged by strengthening their understanding of the models. In this research, we propose a self-review supporting environment that provides learners with feedback generated by translating their Unified Modeling Language (UML) class diagrams into natural language descriptions. This enables beginners to recognize discrepancies between what they would like to describe in their class diagrams and what they actually describe in their class diagrams by comparing them in natural language. We designed three types of templates to make learners aware of the discrepancies. Moreover, we performed an experiment to evaluate whether the feedback produced by translating a learner's model into natural language can support the learner to detect errors in the model themselves, and whether this feedback can support the learner to correct errors in the model themselves. The results of the experiment indicated that the subjects detected errors in their class diagrams with 89.2% accuracy and detected 47.3% of all errors in their diagrams. Furthermore, the subjects corrected the errors they correctly detected with 78.6% accuracy.

Increasingly, students from many different majors are taking foundational courses in Software Engineering (SE) where modelling forms a major part. Novices with limited Object-Oriented (OO) programming skills often find OO modelling concepts abstract and difficult when compared to other topics. In particular, dynamic modelling of sequence diagrams (SDs) was shown to pose the most difficulties when novices learn UML modelling. Novices often do not consider how SDs are constrained by static models such as class diagrams and fail to meet some of the postconditions specified in the use case descriptions. These problems are exacerbated for instructors teaching large classes unable to give adequate formative feedback in the early stages, leading to poor student satisfaction and learning outcomes. This paper explores the efficacy of using a constructivist-learning tool in large classes able to give immediate feedback in the early stages. In this paper, we report our experience of developing an interactive pedagogical tool called SD4ED to help students learn SDs. The main novelty of our approach is the mechanism devised to provide instant feedback while students are creating the SDs based on the constraints for the underlying static model, postconditions specified for the underlying use case and the current knowledge state aggregating past messages. Unlike other UML tools developed in the past, our tool helps students to create consistent and complete models using a constructivist approach. Our pre- and post-tests and survey feedback showed substantially improved learning outcomes and student satisfaction.

The advent of modeling in software engineering, like other engineering fields, has revolutionized the formalism and pace of software development. However, software applications are not built from scratch, instead, other existing software artifacts are reused and combined with new artifacts. This notion of software reuse has been in existence for decades. When structural models such as class diagrams are reused, the reusing and reused models often need to be merged and the result visualized to the modeler. However, layout mechanisms such as GraphViz, JGraphX, and other related layout tools do not retain the original layout and rather arbitrarily layout the merged models. Therefore, important information that corresponds to the mental map of a modeler and is conveyed by the specific layout is currently lost. This paper aims to establish a robust layout algorithm called rpGraph that retains the general layout of the reusing and reused models after merging. rpGraph uses the relative positioning of model elements to inform the positioning of merged model elements. Our findings are evaluated with 20 example model reuses from a library of reusable software model artifacts. A comparison of the merged layouts of rpGraph, GraphViz, and JGraphX shows that rpGraph performs better in terms of retaining the original layouts.

Model-driven engineering advocates the use of different modelling languages and multiple views to describe the characteristics of a complex system. This allows to express a specific system characteristic with the most appropriate modelling language. However, establishing the conceptual relationships between elements from different languages and then consistently maintaining the links between model elements are non-trivial tasks. In this paper, we propose Action-Driven Consistency (ADC) for maintaining the links between different model elements from different languages defined with the Perspectives for Multi-Language Systems (PML) framework. PML aims to promote modularity in language reuse, inter-language consistency, and combination of languages. A perspective groups different languages, each playing a role for a common modelling purpose. PML defines perspective actions based on existing language actions to maintain consistent models. In this work, we present generic templates from which perspective actions can be generated given relationships between language metaclasses. This allows the perspective designer to focus on these key relationships and frees her from the error-prone implementation of perspective actions. We illustrate our approach with a perspective that combines class diagram and use case diagram languages for the purpose of requirement elicitation and apply it to a bank application.

The enrolment of software engineering students has increased rapidly in the past few years following industry demand. At the same time, model-driven engineering (MDE) continues to become relevant to more domains like embedded systems and machine learning. It is therefore important to teach students MDE skills in an effective manner to prepare them for future careers in academia and industry. The use of interactive online tools can help instructors deliver course material to more students in a more efficient manner, allowing them to offload repetitive or tedious tasks to these systems and focus on other teaching activities that cannot be easily automated. Interactive online tools can provide students with a more engaging learning experience than static resources like books or written exercises. Domain modeling with class diagrams is a fundamental modeling activity in MDE. While there exist multiple modeling tools that allow students to build a domain model, none of them offer an interactive learning experience. In this paper, we explore the interactions between a student modeler and an interactive domain modeling assistant with the aim of better understanding the required interaction. We illustrate desired interactions with three examples and then formalize them in a metamodel. Based on the metamodel, we explain how to form a corpus of learning material that supports the assistant interactions.

Learning how to model the structural properties of a problem domain or an object-oriented design in the form of a class diagram is an essential learning task in many software engineering courses. Since the grading of models is a time-consuming activity, automated grading approaches have been developed to assist the instructor by speeding up the grading process, as well as ensuring consistency and fairness for large classrooms. This paper empirically evaluates the efficacy of one such automated grading approach when applied in two real world settings: a beginner undergraduate class of 103 students required to create an object-oriented design model, and an advanced undergraduate class of 89 students elaborating a domain model. The results of the experiment highlight a) the need to adapt the grading strategy and strictness to the level of the students and the grading style of the instructor, and b) the importance of considering multiple solution variants when grading. Modifications to the grading algorithm are proposed and validated experimentally.

Digital twins emerge in many disciplines to support engineering, monitoring, controlling, and optimizing cyber-physical systems, such as airplanes, cars, factories, medical devices, or ships. There is an increasing demand to create digital twins as representation of cyber-physical systems and their related models, data traces, aggregated data, and services. Despite a plethora of digital twin applications, there are very few systematic methods to facilitate the modeling of digital twins for a given cyber-physical system. Existing methods focus only on the construction of specific digital twin models and do not consider the integration of these models with the observed cyber-physical system. To mitigate this, we present a fully model-driven method to describe the software of the cyber-physical system, its digital twin information system, and their integration. The integration method relies on MontiArc models of the cyber-physical system's architecture and on UML/P class diagrams from which the digital twin information system is generated. We show the practical application and feasibility of our method on an IoT case study. Explicitly modeling the integration of digital twins and cyber-physical systems eliminates repetitive programming activities and can foster the systematic engineering of digital twins.

Domain modelling transforms domain problem descriptions written in natural language (NL) into analyzable and concise domain models (class diagrams) during requirements analysis or the early stages of design in software development. Since the practice of domain modelling requires time in addition to modelling skills and experience, several approaches have been proposed to automate or semi-automate the construction of domain models from problem descriptions expressed in NL. Despite the existing work on domain model extraction, some significant challenges remain unaddressed: (i) the extracted domain models are not accurate enough to be used directly or with minor modifications in software development, (ii) existing approaches do not facilitate the tracing of the rationale behind the modelling decisions taken by the model extractor, and (iii) existing approaches do not provide interactive interfaces to update the extracted domain models. Therefore, in this paper, we introduce a domain modelling bot called DoMoBOT, explain its architecture, and implement it in the form of a web-based prototype tool. The bot automatically extracts a domain model from a problem description written in NL with an accuracy higher than existing approaches. Furthermore, the bot enables modellers to update a part of the extracted domain model and in response the bot re-configures the other parts of the domain model pro-actively. To improve the accuracy of extracted domain models, we combine the techniques of Natural Language Processing and Machine Learning. Finally, we evaluate the accuracy of the extracted domain models.

An important skill graduating computing students require is to evaluate a given software design and ensure that it satisfies the intended requirements. Prior work has shown that while working with software designs, experts think deeply about the design and simulate scenarios where the design does not satisfy the requirements. In this paper, we examine how students evaluate a given set of software design diagrams (UML class and sequence diagrams) against the given requirements. We conducted a study with 100 final year computing undergraduate students. Each student was given a sheet which contained the requirements and the design diagrams for a problem. They were asked to identify defects based on the requirements. We used an interpretative content analysis method to come up with categories of student written responses. Our findings show that some students were able to identify scenarios which do not satisfy the requirements (24%) and identify necessary functions which were missing in the design (14%). However, we also found that certain students included new functionalities in the design (10%) and modified existing functionalities (22%) which were unrelated to the given requirements. These findings give insights to what students focus on and the mental models they create while evaluating software design diagrams.

In this paper, we describe the design tracing strategy, which enables students to comprehend class and sequence diagrams by tracing different scenarios. In design tracing, for a given scenario, students identify relevant variables from the class diagram, relevant events from the sequence diagram and trace the flow of these data variables and events by constructing a state diagram. We have developed a web-based learning environment - VeriSIM, which trains students to apply the design tracing strategy. We conducted a study where 86 final-year undergraduates interacted with VeriSIM. Findings from the pre-test and post-test show that students are able to trace a given scenario by identifying relevant variables and events and are able to simulate change of state for these variables. A focus-group interview was also conducted with 13 participants in order to understand their perception of the usefulness of design tracing. A thematic analysis of the focus-group interview showed that students perceived design tracing helped them understand the relationship between different diagrams and identify different scenarios in the design. Interaction with VeriSIM also helped students understand the usefulness of creating class and sequence diagrams. These results show that design tracing can be a useful pedagogy to help learners form an integrated and correct understanding of class and sequence design diagrams.

Drawing is an effective learning tool, incorporating engagement, increasing recall, and improving problem-solving skills. However, it is not widely practiced by computer science educators. This poster reports an analysis of 15 commonly used CS1 textbooks to investigate whether authors encourage students to draw basic programming concepts. One CS1 textbook contained textual encouragement to draw class diagrams and exercises to draw UML diagrams. One other book asked students to graphically represent a class object. We found no encouragement or instructions to draw variables or arrays.

Traceability between system requirements and the artifacts produced by the software development process contributes to the development of reliable software. This paper proposes a method of ensuring traceability by automatically generating an initial sequence diagram from an activity diagram; the activity diagram not only defines user-system interactions, but it also describes the feasibility of use cases via data modeling in a class diagram. These sequence diagrams evolve through changes that are made to the particulars of a system design; these sequence diagrams can be used to generate source code. As a result, the requirements can be traced to the program codes.

Model-based software product lines (MBSPLs) are implemented using various variability mechanisms. These are commonly categorized whether they separate features virtually (e.g., using annotations) or physically (e.g., using modules). Each of these mechanisms comprises advantages and disadvantages regarding MBSPL development, maintenance and analysis. To date, MBSPL developers have to choose upfront which variability mechanism to use, and the chosen mechanism including its drawbacks is bound to the MBSPL's entire lifecycle. In contrast, projectional editing has recently shown very promising potential of making the development of classical SPLs (e.g., implemented in C/C++) more flexible. User-editable projections allow developers to switch fluidly between different variability mechanisms based upon a common internal representation known as variational abstract syntax tree.In this paper, we report on ongoing work on the projectional editing of MBSPLs, which is challenged by a set of additional requirements. We lay the foundation for different editable projections using a common variational abstract syntax graph (vASG) as internal representation. This vASG is used for a fine-grained variability representation of EMOF-based models. We demonstrate the feasibility of our approach by incorporating different variability mechanism projections (150% models and delta modules) and modeling languages (Ecore class diagrams and UML state machines) used in existing MBSPL case studies.

Software product line engineering (SPLE) aims at increasing productivity by relying on the principles of organized reuse and variability. In annotative approaches to SPLE the realization artifacts carry presence conditions, we refer to as annotations below, which express the presence of the artifact in configured products. On the other hand, model-driven software engineering aims at the same effect by raising the level of abstraction and automation through models expressing the system under development. Combining both disciplines seeks to exploit their benefits. In model-driven SPLE the product line typically consists of different kind of models, e.g., class diagrams may capture design decisions whereas Java source code models are enriched by realization artifacts. In order to automatically generate the source code models from the class diagrams, model transformations are written in the single-product development. However, these transformation languages have not been developed with the variability of SPLE in mind, i.e., they are not able to handle annotations out-of-the-box. Consequently, the engineer needs to annotate the target representation manually, contradicting the aim of both disciplines, SPLE and MDSE. Multi-variant model transformations have been proposed as answer to propagate annotations additionally. Since all of them require certain properties to be fulfilled for a correct propagation, still some target annotations may have to be changed or can simply not be determined by the propagation yet. Since software engineering is always an iterative process we like to preserve manual changes in the target representations which requires an incremental behavior of the annotation propagation. However, to the best of our knowledge up to now, no research on this topic has been conducted and, thus, we present strategies in this research-in-progress paper how an incremental propagation can be realized. Moreover, we like to consider incremental behavior also in the correctness criterion.

The study is intended to create a unified modeling and framework that addresses the issue of transparency in the procurement process and utilized an algorithm that will help the University in checking uploaded documents of the Bids and Awards Committee (BAC) tendered items compliant to RA 9184 Procurement Act of the Philippines with open contracting data standard. The research design utilized in the study was descriptive method and prototyping methodology. In order to support the unified modeling and procurement process, the paper presents the architectural view of the system through use case diagram and class diagram to show the interconnections of the entities on the activities in the procurement process, and to identify the methods, functions and relationships of the classes. Furthermore, the researchers designed a system framework to provide a clear perspective of the entire system process.

This paper aims to present an upgraded "Stubs and Drivers Generating Tool" from our previous research [1] which proposed a web-application for generating stubs and drivers for unit testing. However, the tool has limitations in generating stubs and drivers from a class diagram with abstraction and it allows a tester to select only one class under test for generating them while generated drivers do not include test input values. This enhanced tool generates stubs and drivers with test input values using UML sequence and class diagrams. A tester can perform class integration testing automation with the tool by importing both sequence and class diagrams in XML format. Then, extracting and analyzing elements to produce a call graph. The tester can select a group of classes under test. After that, the tool generates a set of stub and driver files for class integration testing. The tool also randomly generates test input values and expected result for drivers. Finally, the tester can customize the source code generated from the tool and export these files for using in class integration testing process.

The software development process comprises a set of activities with the goal of developing high quality software. The software architecture design is a key activity of the software development processs as it allows the specification and visualization of products from different and structured point of views. One of the most used architectural views is the logical one, which represents the classes and their relationships. For this reason, the UML class diagram is one of the most used UML diagrams by software engineers [1]. Many companies use CASE (Computer-Aided Software Engineering) tools to carry out several software engineering activities, including modeling class diagrams. They are looking for independence and flexibility to adapt and integrate tools through the adoption of open-source tools, but this is not an easy task as there are a lot of CASE tools and most of them are incompatible. This problem arises when it is necessary to integrate tools to perform software engineering activity that needs to receive a UML class diagram as input. In this sense, the objective of this work is to assist software engineers in the selection of the tools by presenting results of a systematic review, whose goal was identifying existing free and open-source tools for UML class diagram modeling and analyzing their support to adaptation and integration with other tools. Twelve tools for UML class diagrams modeling were found and an analysis of their support to adaptation and integration with other tools was carried out. This analysis is useful in the choice and use of such kind of tool, either in industry or academic research.

In this paper, we present a multi agent architecture based on Incremental Dynamic Case-Based Reasoning (IDCBR). Our approach inherits from Model Driven Architecture (MDA [11]), which aims to design, develop and implement models or meta-models of multi-agent systems that we build from AUML. We have designed a generic and scalable class diagram to develop complex multi-agent systems [3] for Decision Support System based on IDCBR to predict and anticipate a dynamic situation. The source code of the models is generated by an open source tool called AndroMDA [13]. The model and source code will be used to design and develop applications to implement and simulate multi-agent models for Management of Common Renewable Resources [4].

Software engineering courses play an important role in computer science programs and are expected to provide the required basic knowledge and skills for professional practice in software industry. However, teaching software engineering principles, concepts and practices, and relating them to real-world scenarios are challenging tasks. The adoption of open source software projects may address such challenges. In this paper we report on an experience of the teaching object-oriented modeling with Unified Modeling Language (UML) Class Diagrams using open source projects. We conducted a case study with students of the software engineering discipline of the Computer Science course. We supported the instructor in some activities related to syllabus planning, including the selection of a Free/Libre/Open Source Software (FLOSS) projects and the creation of examples to be used in the classroom. The instructor selected and used a small FLOSS project to support the modeling activities. Then, the instructor applied an evaluation activity and a perception questionnaire about the methodology used. After the end of the classes, we conducted an interview with the instructor to present a brief report of his experience in the classroom. In the perception of students, the experience with FLOSS projects enhanced their ability to handle real projects and third-party code, and to deal with the job market. They also reported developing skills such as proactivity and communication. From the instructor's perspective, the group was enthusiastic and dynamic, and interacted more during practical activities.

Context: The term Technical Debt (TD) is associated with the effect of immature artifacts in the development of software. Although TD may incur in different stages of development, few pieces of research have addressed the relationship between TD in models and its influence on their respective source codes. Goal: To investigate the influence of model refactoring on code debt and vice-versa. Method: A replicated study was conducted considering the refactoring of a Unified Modeling Language (UML) class diagram for the removal of model smells, code issues, and code debt items. Besides, a different round-trip engineering tool was used, other than that employed in the original study. Findings: The findings of the original study were confirmed, but the usage of different engineering tools may influence the quantification of code debt. Conclusion: New replicated studies are necessary to further investigate the influence of model refactoring on code debt, considering other code issues, detection tools and class diagrams.

Unified Modeling Language (UML) has been adopted as a standard modeling language in the software industry for the graphical representation of analysis and design models. Due to its importance, UML is taught in most undergraduate majors in Software Engineering and Computing. However, little is known about the students' perception regarding the UML diagrams. Their perceptions may influence the diagrams' adoption since the students are future software engineers. This paper aims to start filling this gap by better understanding students' perception regarding UML diagrams acceptance. To achieve this goal, we applied a Focus Group to foster a discussion with undergraduate students about five UML diagrams. Besides, we applied the Technology Acceptance Model to assess the students' acceptance regarding these diagrams. Based on the results of this study, students considered use cases and class diagrams useful for designing systems, although they stated that their modeling was not easy. We also noticed that the perceived usefulness was the construct that most influenced the students' intention to use these diagrams. Our research benefits instructors interested in understanding the students' perceptions about UML, enlightening the points that they need to reinforce to show the benefits of the modeling language. Still, the instructors are invited to reflect on other teaching strategies to show the importance of these diagrams in the software development process.

Software product line engineering (SPLE) aims at increasing productivity by following the principles of variability and organized reuse. Combining the discipline with model-driven software engineering (MDSE) seeks to intensify this effect by raising the level of abstraction. Typically, a product line developed in a model-driven way is composed of various kinds of models, like class diagrams and database schemata. To automatically generate further necessary representations from a initial (source) model, model transformations may create a respective target model. In annotative approaches to SPLE, variability annotations, which are boolean expressions over the features of the product line, state in which products a (model) element is visible. State-of-the-art single-variant model transformations (SVMT), however, do not consider variability annotations additionally associated with model elements. Thus, multi-variant model transformations (MVMT) should bridge the gap between existing SPLE and MDSE approaches by reusing already existing technology to propagate annotations additionally to the the target. The present contribution gives an overview on the research we conduct to reuse SVMTs in model-driven SPLE and provides a plan on which steps are still to be taken.

Software design has a main impact in the quality of the software systems. Anti-patterns are shortcomings exist in the software designs and impact negatively software quality. Mobile applications (apps) with anti-patterns have bad quality and short lifetime. Many empirical studies have assessed that the anti-patterns have a negative impact on change-proneness, fault-proneness, memory consumption and energy efficiency. In addition to that, many studies showed that there was an improvement in the user interface and memory performance of mobile apps when correcting Android anti-patterns. The aim of our research is choosing the suitable UML modeling environment to detect Mobile applications' anti-patterns via reverse engineering. So, in this research, first we present a comparative study between nine UML tools for determining the tools that have the functionality for (reverse, forward) engineering and have the ability for validating the model against the anti-patterns. Second, we apply our proposed method to generate the class diagram model of the apps through decoding the Java source code and detects the design anti-patterns in the model. For validating the proposed method, we applied it in twenty-nine Mobile apps which were downloaded from APKmirror. The proposed method detects and treats ten anti-patterns which have appeared 749 times in the twenty-nine apps.

In this paper, we introduce a formative e-assessment tool for building UML class diagrams. Students are tasked to model a UML class diagram for a use case, while choosing a suitable design pattern. The web-based tool is able to automatically assess student solutions and identify the design pattern they applied. This information is then used to advise students on their design pattern choice and give further feedback centred towards an exemplary solution. The paper outlines the applied algorithms for the identification process. Further, we analyse the performance of the design pattern identification based on a field experiment within a CS3 course. In the evaluation, we draw the comparison of our tool's identification quality with that of teachers from the CS3 class. Our results show that the approach is reasonable and helpful for students in order to learn how to select and apply design patterns in different scenarios.

The Unified Modeling Language (UML) is widely used by software engineers in different phases of software development cycle. It allows them to visualise and depict a system into different diagrams. Among these diagrams, UML class diagrams are used to capture the structure of a system including classes, attributes and associations. The set of operation calls defined in a UML class diagram then capture the behaviour of a system. These operation calls typically constrain the inputs and outputs via a set of pre or postconditions (operational contracts) written in Object Constraint Language (OCL). Hence, a sequence of operation calls conforming to pre or postconditions is crucial to analyse, verify and understand the behaviour of a system. In this paper, we propose a new technique for synthesising call sequences from a set of operational contracts. This technique works by reducing a synthesis problem to a satisfiability modulo theories (SMT) problem. The preliminary results show that our technique is capable of synthesising call sequences at a large scale.

UML model matching and retrieval is widely known as optimization problem. This is because of the inconsistencies between software properties. Matching is a fundamental operation for UML model reuse, as such accurate matching between models' elements results in better reuse of such models. UML models consist of number of properties such as functional properties, structural properties, and behavioral properties. Such properties are source of numerous errors during software matching, because each property represents software system from different views. In this paper we empirically investigate the use of different weight values when computing the similarity of software system from multiple views. The paper investigates the improvement of similarity values through the calibration of aggregated metrics. The result reported shows the superiority of structural properties if assign higher metric value compared to other properties.

In model-driven software product line engineering (SPLE) the superset of products is developed over models. A feature model typically states the discriminating and common factors of the software. In annotative approaches model elements are associated with variability annotations which are boolean expressions over the features defining in which products the elements are visible. When the product line is defined over different models, the developer wants to annotate the model of one type and transform it to different representations, e.g., a (UML) class diagram into a relational database schema for establishing an object-relational mapping. Assigning the annotations manually to the target model is an error-prone and laborious task. In a black-box approach we automatically assign the correct annotations to the target model without analyzing the transformation specification. It is an easy task in the case of 1:1 mappings where the annotation of the source element is copied to the corresponding element in the target model. Typically this kind of information is available, e.g., in traces written during the transformation execution. In reality, more complex mappings are frequent but the correspondences harder to determine. Assuming a target model is already annotated with the annotation of 1:1 correspondences, a certain number of elements remains without annotations. This paper contributes strategies to determine missing annotations in partially annotated models. We compare a global include strategy with more sophisticated ones which take the model structure into account. Since we apply missing annotations locally on one model, we solve a general SPLE problem where completely annotated models reduce the manual user effort and are desirable for filtering.

After a developer has developed a software system, his/her customers sometimes claim missing requirements. Since there are various kinds of missing requirements, there are no silver bullets to solve all of these situations. The approach of our research to solve this problem is based on conceptual models. We focus on a web system as an example to find missing requirements with regard to accessing paths to pull certain information from known information. An association between two concepts in a conceptual model implies that a user of the web system traverses from a page in which he/she got information to another page in which he/she will find new information. We exploit a method to derive possible accessing paths from associations in a conceptual model. Class Diagram in UML is applied to draw conceptual models with actors and their accessing permissions; which are, create, read, update, and delete. As a result, linearly connected paths are generated for each actor with regard to their accessing permissions. Each path from one concept to another concept via multiple concepts is called a traverse. The method is implemented as a tool named Traverser. Traverser automatically generates an actors' possible accessing paths with a conceptual model, so that developers and requesters able to become aware of missing requirements. In order to evaluate the effectiveness of the method, we studied a case and clarified whether the tool contributes to the completeness of requirements or not. The domain of the case is academic affairs. As a result of the case study, Traverser was able to generate new accessing paths that had not previously been implemented within the system.

In our research, we design an interactive learning environment for software engineering design patterns. The result is a web-based formative assessment tool, which asks students to choose a suitable design pattern for a given use case and to create a UML class diagram for it. A backend system is able to automatically analyse submissions according to the applied design pattern within each solution. The students are provided with contextualized feedback in order to help them improve their solution and to increase their understanding of design patterns. The paper describes our approach and illustrates the essential parts of the learning environment. Further, we review some insights gathered from a field experiment, in which the learning environment was applied within a software engineering class.

Software Product Line (LPS) is a paradigm that reuses software artifacts throughout a set of systems that have common and variable characteristics. To guarantee the quality of an SPL and, consequently, of its generated products, it is necessary to use verification and validation activities, such as software inspections. Thus, it is possible to detect defects in different artifacts from the earliest stages in a software development cycle. To support this activity there is a number of techniques, such as SMartyCheck, defined as a checklist-based reading technique, which allows inspection of SMarty UML diagrams. It is important to note that the SMartyCheck technique was previously evaluated in two empirical studies (one qualitative and one quantitative) taking into consideration UML use case diagrams and class diagrams. Both studies pointed out significant results in favor of SMartyCheck. SMartyCheck evolved encompassing UML component diagrams. In this sense, this paper presents initial evidence of the evaluation of SMartyCheck applied for defect detection in UML component diagram based on a controlled experiment carried out in the academy. SMartyCheck was compared to Ad Hoc inspection technique and had superior results for effectiveness and efficiency. Accuracy provided no significant difference between both techniques.

In order to achieve effective support for software development, the transition between an informal and provisional mode of tool operation, which is conducive to design exploration, and a formal mechanistic mode required for computer-based design capture is crucial. This contribution proposes a smooth transition for designing class models starting from informal, sketchy object models. We propose a lenient development approach and discuss the possibilities and problems of a transformation from object diagrams to class diagrams. While classes describe abstract concepts, objects are representations of what can be seen in the real world, so it might be easier to start modeling with objects instead of classes. An object diagram can however not describe a whole system, it is only used as the first step of an iterative process to create a complete model. During this process, our object and class diagrams provide a notation for highlighting missing or conflicting parts. Based on these imperfect object diagrams, educated guesses can be made for resulting, imperfect class diagrams, which can then be refined to a complete, formal description of the modeled system.

In this paper, we present a new approach of design and developing multi agent systems. Our approach is based on Model Driven Architecture (MDA), which aims to establish the link between existing agent architectures and the models or meta-models of multi-agent systems that we build from AUML. We have designed a generic and scalable class diagram to develop complex multi-agent systems. The source code of the models is generated by an open source tool called AndroMDA. The model and source code will facilitate the design and development of applications to implement and simulate multi-agent models for Management of Common Renewable Resources. This approach allows reuse of the model and generated source code to develop new applications.

Unified Modeling Language (UML) is a widely used modeling language in the software industry. However, students face difficulties while learning how to model complete and correct UML diagrams. In order to minimize these difficulties, educators perform individual and/or group modeling activities during class. Despite the importance of this problem, there are few experience reports comparing students' performance on these two forms of practicing modeling exercises in the classroom. In this context, this paper describes an empirical study aiming to compare the effects of modeling exercises carried out individually and in group. We evaluated the correctness and completeness of the UML diagrams and use case specification produced by the students and their perceptions about both forms of organization. The results showed that although the students presented difficulties in understanding the syntax, they modeled the use case specification and the class diagram more correctly individually. On the other hand, the students modeled the diagram and use case specification, and the sequence diagram more completely in group. Differently from what we expected, these results suggest that if the instructor's goal is for students to learn to design more correct and complete models, performing group activities not always show more positive learning outcomes. Instead, in some cases, individual modeling is likely to yield better results.

The teaching of the object-oriented paradigm has become a very common practice in the introduction of computer courses and the difficulties in the teaching-learning process of this paradigm are well known. This paper presents the results obtained from analyzes on the process of constructing UML Class Diagrams, through experiments. For this, a tool was developed to support the teaching-learning process of the object-oriented paradigm, during the construction of Class Diagrams. The main objective of the tool is to collect and analyze the data generated by the students during the construction of Class Diagrams, not only evaluating the final model constructed by the students, but the whole course to obtain this model. With the results generated, the teacher had the possibility to individually assist students with their main difficulties in understanding the object-oriented paradigm. It was observed that after the intervention of the teacher, several students were able to become sufficient in the understanding of the concepts of object orientation, reaching the proposed objectives.

A typical database design methodology based on the conceptual modelling is a standard component of many introductory database courses. Evaluation of correctness and quality of conceptual schemas created by the course participants is always a long and tedious task due the large number of solutions and complexity of the solutions. This work describes a new approach to automated evaluation of correctness and quality of database conceptual schemas. We propose a new notation based on simplified UML class diagrams as a way for unified representation of conceptual schemas and we describe a software tool that transforms the different notations into a common one. Many of simple syntactical mistakes can be detected and reported at a transformation stage. Then, we show how to compare the transformed conceptual schemas with a template solution provided by a course instructor and how to list the discrepancies found in the designs.

The paper presents an online two-phase business process model-driven generator of the conceptual database model. The generator is implemented as a web-based, platform-independent tool, in contrast to the existing tools that are dependent on some specific technological platform used for their implementation. Unlike the existing approaches, which are characterised by the direct synthesis of the target model based on business process models represented by a sole concrete notation such as BPMN, the presented generator uses an indirect two-phase approach, which is based on the introduction of a simple domain specific language as an intermediate layer between source and target notations. The implemented online generator enables automatic generation of the target data model represented by UML class diagram, based on business process models represented by two concrete notations: BPMN and UML activity diagram.

Self-adaptive Systems (SaSs) operate under uncertainty conditions and have intrinsic properties that make their modeling a non-trivial activity. This complexity can be minimized by using Domain-Specific Modeling Languages (DSMLs), which may be created by extending Unified Modeling Language (UML). In face of this, we propose investigating how the UML has been customized to create DSMLs that provide proper support for SaSs modeling. To achieve this, we performed a Systematic Literature Review (SRL) by retrieving studies with snowballing technique, selecting studies according to inclusion and exclusion criteria, and extracting and analyzing data to answer our research questions. As the outcome, we retrieved 786 studies and selected 16 primary studies published between 2005 and 2017. The results reveal that the class diagram has been customized through the profile-based mechanism to provide proper support to analysis and design of context-awareness and self-adaptiveness properties.

Context: UML software development relies on different types of UML diagrams, which must be consistent with one another. UML Synthesis techniques suggest to generate diagram(s) from other diagram(s), thereby implicitly suggesting that input and output diagrams of the synthesis process be consistent with one another. Objective: Our aim is to provide a comprehensive summary of UML synthesis techniques as they have been described in the literature to date to then collect UML consistency rules, which can then be used to verify UML models. Method: We performed a Systematic Mapping Study by following well-known guidelines. We selected 14 studies by means of a search with seven search engines executed until January, 2018. Results: Researchers have not frequently published papers concerning UML synthesis techniques since 2004. We present a set of 47 UML consistency rules collected from the different synthesis techniques analyzed. Conclusion: Although UML diagrams synthesis doesn’t seem to be an active line of research, it is relevant since synthesis techniques rely on enforcing diagram consistency, which is an active line of research. We collected consistency rules which can be used to check UML models, specifically to verify if the diagrams of a model are consistent with one another.

Sequence and class diagrams are widely used to model the behavioral and structural aspects of a software system. A size metric that is defined automatically countable from sequence and class diagrams boosts both the efficiency and the accuracy of size estimation by producing reproducible software size measurements. To fulfill the purposes, a size metric called Detailed Use Case Points (DUCPs) is proposed based on the information automatically derived from sequence and class diagrams. The automation is largely supported by our proposed user-system interaction model (USIM) that fills the gap between the system abstraction by the sizing model and the metamodels of the UML diagrams. The effectiveness of our proposed size metric in project effort estimation is validated by an empirical study of 22 historical projects.

Distributed streaming applications, i.e. applications that process massive and potentially infinite streams of data, are becoming increasingly popular in order to tame at the same time the velocity and the volume of Big Data. Designing and developing distributed streaming applications is currently difficult because it involves the employment of 1) complex programming paradigms to deal with the unboundedness of data streams together with 2) distributed streaming engines, each coming with its own APIs. To address the above shortcomings, in this tool demo paper we present StreamGen, a model-driven tool aiming at simplifying the development of distributed streaming applications. StreamGen provides (i) a UML profile to add streaming-specific concepts to standard UML Class Diagrams and (ii) a model-to-text transformation to automatically generate the application code starting from UML models.

The online learning called e-learning is a new learning path that offers to learners to study at their own pace and at the moments that suit them. It is in this perspective that the semantic web has known its emergence in the field of e-learning to offer platforms content more personalized and more adapted to student's and teacher's needs. Since Moodle is the most popular e-learning platform, we propose in this paper to build its OWL ontology by exploring the representative data that we collected from its UML class diagram. The choice of UML class diagram as a basis for data collection for the development of the ontology is justified by the fact that the transition from UML to OWL ontology brings ontology development process closer to the wider software engineering population. The built ontology brings also great benefit in the field of the Social Learning Network Analysis. Because it gives the opportunity to study the behavior of the platform users by giving meaning to their relationships instead of modelling them only as knots and edges.

As a two-dimensional formal method, graph grammar is widely used in defining various visual programming languages. This paper presents a new graph grammar formalism called coordinate graph grammar (CGG). CGG is extended from the edge based graph grammar (EGG) by introducing the spatial mechanism into the theoretical framework. This paper focuses on several important issues on the new formalism. First, formal definitions for spatial semantic is given; Second, a new matching algorithm is proposed, which uses the spatial relationships between nodes to narrow down the search space. Finally, an application of CGG is put forward, which generates an UML class diagram in a uniform layout.

The features developed by a software engineer (system specification) for a software system may significantly differ from the features required by a user (user requirements) for their envisioned system. These discrepancies are generally resulted from the complexity of the system, the vagueness of the user requirements, or the lack of knowledge and experience of the software engineer. The principles of software engineering and the recommendations of the ACM's Software Engineering Education Knowledge (SEEK) document can provide solutions to minimize these discrepancies; in turn, improve the quality of a software system and increase user satisfaction. In this paper, a software development framework, called SETh, is presented. The SETh framework consists of a set of visual models that support software engineering education and practices in a systematic manner. It also enables backward tracking/tracing and forward tracking/tracing capabilities - two important concepts that can facilitate the greenfield and evolutionary type software engineering projects. The SETh framework connects every step of the development of a software system tightly; hence, the learners and the experienced software engineers can study, understand, and build efficient software systems for emerging data science applications.

The paper presents a tool to transform Simulink models into UML models. The embedded control software design process can be divided into the control logic design phase and the software design phase. MATLAB/Simulink is widely used to build a controller model in the control logic design phase. On the other hand, UML is widely used in the software design phase. We have developed a model transformation tool to transform Simulink models into UML models: class diagrams, object diagrams, sequence diagrams, communication diagrams, activity diagrams and state machine diagrams. We have applied the model transformation tool to a number of Simulink models and have confirmed its usefulness for embedded control software design.

Big data is defined as a very large data set (volume), velocity and variety. Big data analytics systems must be supports for parallel processing and large storage. The problem of this research is how to identify measurement metric based on big data analytics system characteristic. One device that support big data platform is Hadoop. Measurement is a process for assigning values or symbols to the attributes of an entity. The purpose of measurement is to distinguish between entities one to another. Indicator for software measurement represented with a metric. The aim of this research is to proposes some measurement metric for big data analytics system. This research using UML exactly a class diagram in system modelling to identify the measurement metric. Both of dynamic and static metric is proposed as solution to measure big data analytics system. Result for this researh are some measurement ndicator both of dynamic and static metric based on class diagram for big data analytics.

1Activity diagram is a model view to describe the behavior of the system, has a wide range of applications. Therefore, the research of collaborative activity diagram editing system has a great significance. The paper defines the object of activity diagram and builds the model of diagram theory. Firstly, we analysis the general operation and composite operation in collaborative activity diagram. Then we analysis several conflicts with the CB_ObjSet(basic activity diagram object of composite operation) and the HB in local operation queue, such as Group-Ungroup conflict, Ungroup-Ungroup conflict, Update-Update conflict, Update-Delete conflict and Delete-Delete conflict. We use several methods (such as role operation privilege, collaborative text edit and multi-version) to handle different conflicts. Through these methods, we solved conflicts that have dependence relation. At last, an example given to prove the effectiveness of the new strategy.

Sequence diagram is used to illustrate the exchanging of information between users and system's components. Sequence diagram helps in leveling up the requirement description. The analyst is the role who is manually performing the developing of sequence diagram. The skill of defining objects (or roles) and their exchanged messages are highly depending on the user's expert to recognize sequence diagram units from different sources of information. It is very hard to find UML's reference that describes enough direct rules (specially for many trainee developers) to develop sequence diagram. This paper contributes a definition of a systematic a semi-automated algorithmic approach for generating sequence diagram. Flow of events included in a use case model is used as an input. Semantic Role Labeling (SRL) is the process used to discover the thematic role, which is used to determine the elements of sequence diagram. The extracted elements of sequence diagram are to be fed to a ready-made software tool for sketching sequence diagram. This algorithmic approach provides a direct starting, clear linguistic process, and easy-to-follow practice for developing sequence diagram. The semi-automated approach is viewed as a step towards developing an Intelligent Computer Aided Software Engineering (I-CASE) tool for sketching sequence diagram from flow of events of a use case model.

This paper basically focuses on improving readability of software models. The goal of this research is the enhancement of readability and usability of UML diagrams which increases the interaction between users, programmers and software. UML generally focuses on the main aspect of the software, putting aside other concerns or "useful information" and only tries to display specific aspect at a certain time. Although, specific representation simplifies the understandability of whole diagram, removes useful contextual information. We demonstrate how to represent contextual information by visualizing "useful information" in UML diagrams. These diagrams are created from Java code using reverse engineering plug-in. This goal is achieved by adding extra information to diagram elements in form of different visual variables (such as color, brightness, text and border decoration, etc.). "Useful information" could be any obtained information during the software proceeding. Useful information and its relevant visual variables have been mapped to Java annotations, and this visualized information has been added to diagram. Embedding the "useful information" as Java annotations was done by means of Java language. Afterward, representing and visualizing contextual information in UML diagrams was conducted by JavaScript.

There is no information system for medicinal herb management in oriental medical clinicsin Korea. The purpose of this paper is to design the medicinal herb management system for developing the system. To do this, the requirement analysis is first performed to elicit the requirements from stakeholders of the medicinal herb management system. Next, the system configuration of the medicinal herb management system is proposed and the system architecture for developing the system is designed. Finally, class diagrams and sequence diagrams are designed to develop the medicinal herb management system in design phase.