Zhiyi Ma

Schedule of Bad Smell Detection and Resolution: A New Way to Save Effort

Bad smells are signs of potential problems in code. Detecting and resolving bad smells, however, remain time-consuming for software engineers despite proposals on bad smell detection and refactoring tools. Numerous bad smells have been recognized, yet the sequences in which the detection and resolution of different kinds of bad smells are performed are rarely discussed because software engineers do not know how to optimize sequences or determine the benefits of an optimal sequence. To this end, we propose a detection and resolution sequence for different kinds of bad smells to simplify their detection and resolution. We highlight the necessity of managing bad smell resolution sequences with a motivating example, and recommend a suitable sequence for commonly occurring bad smells. We evaluate this recommendation on two nontrivial open source applications, and the evaluation results suggest that a significant reduction in effort ranging from 17.64 to 20 percent can be achieved when bad smells are detected and resolved using the proposed sequence.

Facilitating software refactoring with appropriate resolution order of bad smells

Bad smell is a key concept in software refactoring. We have a bunch of bad smells, refactoring rules, and refactoring tools, but we do not know which kind of bad smells should be resolved first. The resolution of one kind of bad smells may have impact on the resolution of other bad smells. Consequently, different resolution orders of the same set of bad smells may require different effort, and/or lead to different quality improvement. In order to ease the work and maximize the effect of refactoring, we try to analyze the relationships among different kinds of bad smells, and their impact on resolution orders of these bad smells. With the analysis, we recommend a resolution order of common bad smells. The main contribution of this paper is to motivate the necessity to arrange resolution orders of bad smells, and recommend a resolution order of common bad smells.

Applying OO Metrics to Assess UML Meta-models

UML has been coming of age through more than seven years development, in which there are not only minor revision like from UML 1.1 to UML 1.2, but also significant improvement like final adoption of UML 2.0 submissions. However there is so far lack of an objective assessment to UML meta-models, which can be used to control and predict the evolution of the UML. In this paper we regard UML meta-models as the equivalent of Object-Oriented (OO) design models. Therefore, we can adapt OO design metrics and criteria as a method to assess UML meta-models. Our method conducts the assessment of stability and design quality to UML meta-models in versions of 1.1, 1.3, 1.4 (with Action Semantics), 1.5, and 2.0. Based on the results we analyze the evolution of the UML versions and provide the applicability suggestions to the method.

A metamodel for the notation of graphical modeling languages

In order to define a graphical modeling language, it is necessary to define the graphical notation of the language in the process of metamodeling. So the defining of the notation has become one of the essential functions in meta-modeling tools. This paper proposed the Notation Definition Metamodel (NDM) for metamodeling tools. NDM is used to define the graphical notation. It consists of three parts: basic figures and layouts, location relations and syntax bridges. NDM has been implemented in PKU Meta- Model Tool (PkuMMT). The paper made a case study to illustrate the feasibility of NDM. Besides, a comparison between PKU MMT and some metamodeling tools is presented to show the capability and advantages of NDM.

Integrating Non-functional Requirement Modeling into Model Driven Development Method

Model Driven Development views application development as a continuous transformation of models of the target system. However, non-functional requirements, which are important for building user-satisfied software systems and have impacts on the software design, are not sufficiently considered in current MDD methods. This paper proposes an approach to modeling non-functional requirements, analyzing their impacts to the design and making a complement to the original design models for the MDD methods. First, existing UML models of the application’s functional properties are taken as an input of the NFR modeling process, and with a NFR repository, the NFRs are refined and operationalized. Then based on the analysis result, modeling constructs are created to implement them, and the original UML models are reversely augmented by the result of NFR modeling. In particular, a metamodel is proposed to model the new constructs and facilitate the integration process. With this approach, we can finally get an integrated design model considering both functional requirements and non-functional requirements. The feasibility of the proposed approach is illustrated with an example of the design of a simplified credit card system.

On the Classification of UML’s Meta Model Extension Mechanism

Although the UML meta model extension mechanism has been used in many modeling fields in which extension of UML is needed, UML specification has little necessary classification and application guidance on the meta model extension mechanism. This paper defines four levels of UML’s meta model extension mechanism, and discusses the readability, expression capability, use scope and tool support on the basis of precise definitions of each level. The work on the paper reinforces the maneuverability of the UML meta model extension mechanism, and provides a reliable theoretical base for the development of modeling tools that support meta model extension.

Identification of generalization refactoring opportunities

Generalization refactoring helps relate classes and share functions, including both interfaces and implementation, by inheritance. To apply generalization refactoring, developers should first identify potential generalization refactoring opportunities, i.e., software entities that might benefit from generalization refactoring. For non-trivial software systems, manual identification of these opportunities is challenging and time-consuming. However, to the best of our knowledge, no existing tools have been specifically designed for this task. As a result, people have to identify these opportunities manually or with the help of tools designed for other purposes, e.g., clone detectors. To this end, we propose a tool GenReferee (Generalization Referee) to identify potential refactoring opportunities according to conceptual relationship, implementation similarity, structural correspondence, and inheritance hierarchies. It was first calibrated on two non-trivial open source applications, and then evaluated on another three. Evaluation results suggest that the proposed approach is effective and efficient.

QODM: A query-oriented data modeling approach for NoSQL databases

Cloud applications on the cloud computing platform are different from traditional applications. In addition to SQL databases, cloud applications usually store their data in NoSQL databases. However, most NoSQL databases do not support join operations. Therefore, the traditional relational data modeling approach is not suitable for NoSQL databases, and it makes data query more complex in NoSQL databases. According to the characteristics of NoSQL databases, we proposed a query-oriented data modeling approach for NoSQL databases. This approach can generate data models and data schemas for NoSQL databases based on the stored data structure and data query requirements of an application. Furthermore, we defined a platform independent model of data schema for NoSQL databases. Moreover, we used ElasticInbox, a real cloud application, to evaluate the availability and platform independence of the QODM approach.

Scheduling of conflicting refactorings to promote quality improvement

Software refactoring is to restructure object-oriented software to improve its quality, especially extensibility, reusability and maintainability while preserving its external behaviors. For a special software system, there are usually quite a few refactorings available at the same time. But these refactorings may conflict with each other. In other words, carrying out a refactoring may disable other refactorings. Consequently, only a subset of the available refactorings can be applied together, and which refactorings will be applied depends on the schedule (application order) of the refactorings. Furthermore, carrying out different subsets of the refactorings usually leads to different improvement of software quality. As a result, in order to promote the improvement of software quality, refactorings should be scheduled rationally. However, how to schedule refactorings is rarely discussed. Usually, software engineers carry out refactorings immediately when they are found out. They do not wait until all applicable refactorings are found out and scheduled. In other words, the refactorings are not scheduled explicitly, and conflicts among them are not taken into consideration. Though more and more refactorings are formalized and automated by refactoring tools, refactoring tools apply refactorings usually in a nondeterministic fashion (in random). In this paper, we propose a scheduling approach to schedule conflicting refactorings to promote the improvement of software quality achieved by refactorings. Conflicts among refactorings are detected, and then a scheduling model is presented. And then a heuristic algorithm is proposed to solve the scheduling model. Results of experiments suggest that the proposed scheduling approach is effective in promoting the improvement of software quality

A web based UML modeling tool with touch screens

With the popularity of pads, large touch screens, notebooks and smart mobiles, it is a reasonable requirement that modelers use such devices to models. However, there are few modeling tools that take full advantage of the devices. This paper discusses a Web based UML modeling tool with touch screens, based on our full analysis of human-machine interaction modes for software modeling. The tool provides more input means, i.e. combining gesture input and traditional keyboard and mouse input, and supports cross-platforms modeling by using HTML 5.