In cloud computing, variability becomes a crucial ability of process-based cloud applications. Existing solutions either focused on modeling variability in the architectural model or tried to support dynamic variability management in implementation. An integrated approach that can inherit the virtues from both categories is expected. The paper aims to fill the gap by proposing a model-driven variability-based service composition approach. We propose VxUML to model the variability in the architecture model. Then, we define a set of model transformation rules to convert VxUML into VxBPEL (an extension to standard BPEL supporting variability at the implementation level). Finally, we implement a prototype tool, and present a case study to demonstrate the feasibility of our approach.

As more and more multi-tenant applications emerge in clouds, people increasingly recognize the importance of multi-tenant applications in realizing cloud benefit maximization. Service Level Agreement (SLA) is advocated widely to monitor these applications for multiple tenants to meet their service quality requirements. However, so far these applications provide limited multi-tenant monitoring supports, which prevents the applications from guaranteeing tenants' interests efficiently. In this paper, we propose an aspect-oriented approach to monitor multi-tenant applications based on tenant SLAs. Our approach includes monitoring code generation and runtime management. During code generation, the approach proposes an SLA feature model for tenants to specify variable requirements. Based on the requirements the approach selects code snippets, which are implemented as templates in advance, and splices them into an monitoring aspect. During runtime, the approach prioritizes aspects to determine execution order and updates monitoring status in term of tenant. An implemented prototype is used to evaluate the approach by case studies, which demonstrate the approach effectiveness in common situations.

As multi-tenant applications spring up in clouds, more and more people advocate using Service Level Agreement (SLA) in service delivery to fit tenants' non-functional needs e.g. Response time and budget limit. However, most of the present application optimizations based on SLA focuses on virtual machine-based (VM-based) computing service, while other services such as storage and cache are often neglected. In this paper, we propose an SLA-driven application optimization for cache service to help to meet tenants' needs better and improve cost-effectiveness, which can be taken as complementary to the existing work. The proposed approach, built on top of Platform-as-a-Service (PaaS), pays attention to evicted data. It considers both tenant SLA-evaluated status and data performance when weighting the evicted data with re-cache likelihoods, and then adjusts their re-cache priorities. At the beginning of every cycle it predicts tenant status and evicted data performance for the coming cycle by Holt-Winters double exponential smoothing. Our simulation experiments demonstrate the optimization effectiveness in improving cache cost-effectiveness and satisfying tenant SLAs.

Mode transformation is the key to model-based software engineering. When the model transformation is applied to industrial developments, its scalability becomes an important issue, since the model to be transformed may have a large size. To test the performance of model transformations, this paper proposes a randomized approach to generating large models as test inputs. First, the paper discusses the basic requirements and constraints for performance test input generation of the model transformation. Then, the paper presents our model generation algorithm. It can generate a model having a large size randomly and correctly within a reasonable time, according to the metamodel and user-defined constraints. Finally, an evaluation is also presented. And the result shows that our approach is more suitable for generating performance test inputs compared with existing model generation approaches.

Cloud computing encourages application to migrate into it for economic of scale, where they rent shared resources to deliver services. Service Level Agreements(SLA) plays an important role in assisting various applications providing high-quality services to end users in cloud's complex and uncertain environments. Most of the existing work tries to support application claimed quality by help cloud make decisions of computing resources allocation during runtime. In this paper, we propose an approach for applications to maintain quality requirements by runtime cache adjustment in consideration of service level objectives (SLOs) and unpredictable workload in cloud, which can be taken as a complement to the existing work. Our approach includes application SLO modeling and mapping to monitor metrics during runtime, and an algorithm to adapting caches according to runtime status and SLOs. The approach has been applied to a real-world SNS application which proves effectiveness of our approach.

Software refactoring is an effective method for improvement of software quality while software external behavior remains unchanged. To facilitate software refactoring, a number of tools have been proposed for code smell detection and/or for automatic or semi-automatic refactoring. However, these tools are passive and human driven, thus making software refactoring dependent on developers' spontaneity. As a result, software engineers with little experience in software refactoring might miss a number of potential refactorings or may conduct refactorings later than expected. Few refactorings might result in poor software quality, and delayed refactorings may incur higher refactoring cost. To this end, we propose a monitor-based instant refactoring framework to drive inexperienced software engineers to conduct more refactorings promptly. Changes in the source code are instantly analyzed by a monitor running in the background. If these changes have the potential to introduce code smells, i.e., signs of potential problems in the code that might require refactorings, the monitor invokes corresponding smell detection tools and warns developers to resolve detected smells promptly. Feedback from developers, i.e., whether detected smells have been acknowledged and resolved, is consequently used to optimize smell detection algorithms. The proposed framework has been implemented, evaluated, and compared with the traditional human-driven refactoring tools. Evaluation results suggest that the proposed framework could drive inexperienced engineers to resolve more code smells (by an increase of 140 percent) promptly. The average lifespan of resolved smells was reduced by 92 percent. Results also suggest that the proposed framework could help developers to avoid similar code smells through timely warnings at the early stages of software development, thus reducing the total number of code smells by 51 percent.

Estimating the cost is important for cloud application developers to services in clouds, and becomes even important when it needs remaining a certain service level at the same time. Though currently much work has been down to predict cost and performance of cloud applications, most of them perform either before application design or after the application construction, which leads to either imprecise estimation or irreparable design fault. In this paper, we propose an approach to estimate the cost of running typical applications in Amazon Web Service (AWS) cloud during design phase. We propose an UML Activity-extended model (AeModel) to describe execution of application service and introduce an extraction algorithm to extract information contained in the AeModel automatically. We propose a cost model on AWS, which can help developers to estimate operating cost during design phase and satisfy performance needs, with an algorithm to produce suitable purchase solutions automatically. We perform case studies using a web-based business application to show effectiveness of our approach, and find that our approach can help developers lessen cost by adjusting application models.

Pervasive computing technologies can benefit the injured, disabled or elderly people in their daily lives, and smart wheelchair has been a representative of this kind of technologies. However, most existing smart wheelchairs have limitations on extensibility and flexibility of building new functionalities. One big reason is they are just stand-alone ones considering other wheelchairs and surrounding things as dummy objects. To address this issue, we proposed an integrated and collaborative approach: Smarter Wheelchairs that can “talk” to each other, and even “talk” to other things in the surrounding. Smarter Wheelchairs take advantages of smart objects deployed in living environment or hospital environment. Smarter Wheelchairs can harness functions provided by smart objects, therefore, their functionality can be flexibly extended. We have implemented and evaluated a prototype system of Smarter Wheelchairs to demonstrate the feasibility and efficiency of our approach.

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.

Recently model transformations quickly become large size and complex in structure. It is necessary to apply the modeling technique when developing transformations to manage the complexity. The paper proposes VisTML - a visual modeling language for model transformations. It provides six diagrams, which cover the whole lifecycle of transformation development and enable us to specify a transformation from various views and in different phases, i.e. the goal diagram, the transformation diagram, the rule diagram, the composition diagram, the test diagram, and the deployment diagram. We also provide a tool support and a real case of VisTML to illustrate the feasibility of VisTML. Besides, a comparison of VisTML, UML, and transML is presented at last.

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.

Selecting high quality services from available ones plays an important role in services composition. Trust and reputation mechanisms offer a promising way to solve the services selection problem. Current researches on this topic focus on gathering, storing and aggregating feedbacks which can be execution data by monitoring services or consumer ratings. However, besides the feedback itself, the reliability of feedbacks should be considered equally crucial. In this paper, different from previous work, we draw our attention to find trusted feedback submitters who are more likely to give reliable feedbacks. We proposed a service evaluation framework where a "Web of Trust" is built and maintained. Moreover, we presented a Kalman Filter based algorithm to reveal the trusted feedback submitters. The presented work in this paper aims to supplement the service evaluation and ultimately facilitate the services selection process. We validated our approach by both simulated and real-world evaluations.

This paper describes a service oriented programming platform for Internet-based virtual computing environment (iVCE), which is targetted for enabling collaboration among autonomous entities over Internet. This platform provides mechanisms and facilities to help iVCE programmers write and run applications in a relatively stable and trusted environment. In this platform, autonomous entities first voluntarily join in virtual community attracted by common interests. Then entities will selectively play specific roles predefined in collaboration process which is specified in a declarative language named APEL. Capability requirements and environment specifications are also provided to enable negotiation and adaptation while process is executed. All business interfaces and negotiation interfaces are published using standard Web services to maximize reuse and interoperation.

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. Con-sequently, different resolution orders of the same set of bad smells may require different effort, and/or lead to differ-ent quality improvement. In order to ease the work and maximize the effect of refactoring, we try to analyze the re-lationships 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.

Trust and reputation mechanisms offer a promising way to solve the web services selection problem. Currently, many researches on this topic focus on collecting, storing and aggregating feedbacks which can be execution data from monitoring web services or user ratings reported by service consumers for web services evaluation. However, besides considering the evaluation methods, the reliability of feedbacks becomes equally crucial. It is pointed out that the accuracy of a web service's reputation evaluation will be reduced as unreliable feedbacks are used. Therefore, the elicitation of trusted feedbacks and feedbackers becomes very important. In this paper, we managed to elicit trusted users in our service registry through building and maintaining a "Web of Trust". We mined this web of trust by our proposed algorithm which is based on the Kalman Filter Algorithm and analyzed the trustworthiness for each user. Feedbacks reported by trusted users then should be considered more reliable than others to ultimately facilitate the web services selection process.

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 no- tation has become one of the essential functions in meta- modeling tools. This paper proposed the Notation Defini- tion 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 syn- tax 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 pre- sented to show the capability and advantages of NDM.

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

With the popularity of UML and MDA, models are replacing source code as core artifacts of software development and maintenance. But duplications in models reduce models' maintainability and reusability. To address the problem, we should detect duplications first. As an initial step to address the problem, we propose an approach to detect duplications in sequence diagrams. With special preprocessing, we convert 2-dimensional sequence diagrams into a 1-dimensional array. Then we construct a suffix tree of the array. We revise the traditional construction algorithm of suffix trees by proposing a special algorithm to detect common prefixes of suffixes. The algorithm ensures that every duplication detected with the suffix tree can be extracted into a separate reusable sequence diagram. With the suffix tree, duplications are found as refactoring candidates. With tool support, the proposed approach has been applied to real industrial projects, and the evaluation results suggest that the approach is effective.

Component based software development (CBSD) becomes a popular paradigm for Internet based systems. Compared to other popular paradigms, CBSD supports the development from reusable components other than the development from the scratch. Consequently, modeling becomes more important than programming and the modeling techniques in traditional paradigms have to be changed more or less. Particularly, improper selection and misuse of modeling techniques would prevent the target system from benefiting from CBSD and even make the project fail. For helping researchers and practitioners to equip with CBSD, this tutorial will provide basic knowledge and skill of modeling component based systems systematically. Firstly, we will introduce the technical and non-technical motivations of CBSD with emphasis on software reuse which puts a significant impact on modeling. Secondly, we will present a systematic approach to modeling component based systems with a set of existing well-proved modeling techniques, including feature modeling for requirements specification, architecture modeling for abstract design, and object oriented modeling for detailed design. These modeling techniques and a real-life project will be discussed in details in the rest of the tutorial.

JPEG2000 is an emerging standard for still image compression and is becoming the solution of choice for many digital imaging fields and applications. An important aspect of JPEG2000 is its "compress once, decompress many ways" property [1], i. e., it allows extraction of various sub-images (e.g., images with various resolutions, pixel fidelities, tiles and components) all from a single compressed image codestream. In this paper, we present a flexible and scalable authentication scheme for JPEG2000 images based on the Merkle hash tree and digital signature. Our scheme is fully compatible with JPEG2000 and possesses a "sign once, verify many ways" property. That is, it allows users to verify the authenticity and integrity of different sub-images extracted from a single compressed codestream protected with a single digital signature.