Weizhong Shao

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.

Conflict-aware schedule of software refactorings

Software refactoring is to restructure the internal structure of object-oriented software to improve software quality, especially maintainability, extensibility and reusability while preserving its external behaviours. According to predefined refactoring rules, we may find many places in the software where refactorings can be applied. Applying each refactoring, we may achieve some effect (quality improvement). If we can apply all of the available refactorings, we can achieve the greatest effect. However, the conflicts among refactorings usually make it impossible. The application of a refactoring may change or delete elements necessary for other refactorings, and thus disables these refactorings. As a result, the application order (schedule) of the available refactorings determines which refactorings will be applied, and thus determines the total effect achieved by the refactoring activity. Consequently, conflicting refactorings had better be scheduled rationally so as to promote the total effect of refactoring activities. However, how to schedule conflicting refactorings is rarely discussed.In this paper, a conflict-aware scheduling approach is proposed. It schedules refactorings according to the conflict matrix of refactorings and effects of each individual refactoring. The scheduling model is a multi-objective optimisation model. We propose a heuristic algorithm to solve the scheduling model. We also evaluate the proposed scheduling approach in non-trivial projects. Evaluation results suggest that refactoring activities with the scheduling approach lead to greater effect (quality improvement) than refactoring activities without explicit scheduling.

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.

A block oriented fingerprinting scheme in relational database

The need for protecting rights over relational data is of ever increasing concern. There have recently been some pioneering works in this area. In this paper, we propose an effective fingerprinting scheme based on the idea of block method in the area of multimedia fingerprinting. The scheme ensures that certain bit positions of the data contain specific values. The bit positions are determined by the keys known only to the owner of the data and different buyers of the database have different bit positions and different specific values for those bit positions. The detection of the fingerprint can be completed even with a small subset of a marked relation in case that the sample contains the fingerprint. Our extensive analysis shows that the proposed scheme is robust against various forms of attacks, including adding, deleting, shuffling or modifying tuples or attributes and colluding with other recipients of a relation, and ensures the integrity of relation at the same time.

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.

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