A methodology to infer and refactor an object‐oriented model from C applications

When analyzing legacy code, generating a high‐level model of an application during the reverse engineering process helps the developers understand how the application is structured and how the dependencies relate the different software entities. Within the context of procedural programming languages (such as C), the existing approaches to get a model of the code require documentation and/or implicit knowledge that stakeholders acquire during the software building. These approaches use the code itself to build a syntactic model where we see the different software artifacts, such as variables, functions, and modules. However, there is no supporting methodology to detect and analyze if there are relationships/dependencies between those artifacts, such as which variable in a module is declared using an abstract data type described in another one, or which are the functions that are using parameters typed with an abstract data type; or any design decision taken by original developers, such as how the developer has implemented functions in different modules. On the other hand, current developers use object‐oriented (OO) paradigm to implement not only business applications but also useful methodologies/tools that allow semiautomatic analysis of any application. We must remark the legacy procedural code still has worth and is working in several industries, and as any evolving code, the developers have to be able to perform maintenance tasks minimizing the limitations offered by the language. Based on useful properties that the OO paradigm (and their supporting analysis tools) provide, such as UML models, we propose M2K as a methodology to generate a high‐level model from legacy procedural code, mainly written in Ansi C. To understand how C‐based applications were implemented is not a new problem in software reengineering. However, our contribution is based on building an OO model and suggesting different refactorings that help the developer to improve it and to eventually guide a new implementation of the target application. Specifically, the methodology builds cohesive software entities mapped from procedural code and makes the coupling between C entities explicit in the high‐level model. The result of our methodology is a set of refactored class candidates: a structure that groups a set of variables and a set of functions obtained from the C applications. Based on the class candidate model, we propose refactorings based on OO design principles to improve the design of the application. The most relevant design improvements were obtained with algorithm abstraction by applying the strategy pattern, attributes/methods relocalization, variables types generalization, and removing/renaming methods/attributes. Besides a methodology and the supporting tool, we provide 14 case studies based on real projects implemented in C, and we showed how the results validate our proposal.     

Leveraging legacy codes to distributed problem‐solving environments: a Web services approach

This paper presents WSOWG, a Web‐services‐oriented wrapper generator for automatically wrapping non‐networked legacy codes as Web services for reuse in distributed problem‐solving environments. Using WSOWG, a finite element based computational fluid dynamics (CFD) legacy code has been wrapped as a Web service. A problem‐solving environment for simulating incompressible Navier–Stokes flows has also been implemented. A user makes use of the CFD service through a Web page without knowing the exact implementation of the service. In this way, a user's computing environment can be extended to a heterogeneous distributed computing environment. Performance evaluation shows that the overhead to invoke the CFD Web service generated by WSOWG using Simple Object Access Protocol (SOAP) and CORBA Internet Inter‐ORB Protocol (IIOP) is reasonable compared with that of invoking another CFD Web service manually wrapped from the CFD legacy code using SOAP only. Copyright © 2004 John Wiley & Sons, Ltd.     

A linguistic multicriteria decision‐making model applied to hotel service quality evaluation from web data sources

Currently, there are a large number of hotel Web sites that develop their own seals of quality based on customer feedback. As a result, a hotel can be classified differently by various Web sites at the same time, creating confusion in the consumer perceptions about the quality of a given hotel. Moreover, there are attempts to standardize such service quality evaluation, such as the SERVQUAL instrument, which is a multiple‐item scale for measuring service quality with several dimensions. In this context, we present a two‐stage linguistic multicriteria decision‐making model to integrate the hotel guests' opinions included in several Web sites, with two objectives: on the one hand, obtaining a SERVQUAL scale evaluation value of service quality with the integrated answers of the input opinions; on the other hand, getting a SERVQUAL overall evaluation value of service quality. This model is incorporated into an opinion aggregation architecture to integrate heterogeneous data (natural language included) from various tourism Web sites. As a particular case study, we show an application example using the high‐end hotels located in Granada (Spain). © 2012 Wiley Periodicals, Inc.     

Model‐based code generation for HLA federates

This paper addresses the problem of automated code generation for a High Level Architecture compliant federate application given its behavior model. The behavior model is a part of the architectural model of a federation that the federate can participate in. The federate behavior model is based on Live Sequence Charts, adopted as the behavioral specification formalism in the Federation Architecture Metamodel (FAMM). FAMM serves as a formal language for describing federation architectures. An objective is to help the testing of federation architecture by means of its prototype implementation early in the development lifecycle. A further objective is to help developers construct complete federate applications that are well modularized. The approach to achieve these objectives is aspect‐oriented in that the generated code, which handles the federate's interactions with a federation execution, serves as the base code, where the computation logic is to be weaved as an aspect. Copyright © 2009 John Wiley & Sons, Ltd.     

High‐level specifications for automatically generating parallel code

The arrival of multicore systems, along with the speed‐up potential available in graphics processing units, has given us unprecedented low‐cost computing power. These systems address some of the known architecture problems but at the expense of considerably increased programming complexity. Heterogeneity, at both the architectural and programming levels, poses a great challenge to programmers. Many proposals have been put forth to facilitate the job of programmers. Leaving aside proposals based on the development of new programming languages because of the effort this represents for the user (effort to learn and reuse code), the remaining proposals are based on transforming sequential code into parallel code, or on transforming parallel code designed for one architecture into parallel code designed for another. A different approach relies on the use of skeletons. The programmer has available set of parallel standards that comprise the basis for developing parallel code while programming sequential code. In this context, we propose a methodology for developing an automatic source‐to‐source transformation in a specific domain. This methodology is instantiated in a framework aimed at solving dynamic programming problems. Using this framework, the final user (a physician, mathematician, biologist, etc.) can express her problem using an equation in Latex, and the system will automatically generate the optimal parallel code for homogeneous or heterogeneous architectures. This approach allows for great portability toward these new emerging architectures and for great productivity, as evidenced by the computational results.Copyright © 2012 John Wiley & Sons, Ltd.     

基于UML的文档管理系统研究

统一建模语言UML（Unified Modeling Language）是面向对象软件开发方法的重要技术。UML可以对大型复杂的系统的各种成分可视化，说明并构造系统模型，以及建立各种所需的文档。本文以文档管理系统为例，介绍了Intranet／Web体系结构的信息系统站点的构建，以及基于ASP和ISAPI的动态Web页面发布技术，并对基于Intranet和Web技术应用的一些典型问题进行了分析。     

A comprehensive solution for application‐level adaptation

Driven by the emergence of mobile and pervasive computing there is a growing demand for context‐aware software systems that can dynamically adapt to their run‐time environment. We present the results of project MADAM that has delivered a comprehensive solution for the development and operation of context‐aware, self‐adaptive applications. The main contributions of MADAM are (a) a sophisticated middleware that supports the dynamic adaptation of component‐based applications, and (b) an innovative model‐driven development methodology that is based on abstract adaptation models and corresponding model‐to‐code transformations. MADAM has demonstrated the viability of a general, integrated approach to application‐level adaptation. We discuss our experiences with two real‐world case studies that were built using the MADAM approach. Copyright © 2008 John Wiley & Sons, Ltd.     

Model‐to‐model and model‐to‐text: looking for the automation of VigilAgent

VigilAgent is a methodology for the development of agent‐oriented monitoring applications that uses agents as the key abstraction elements of the involved models. It has not been developed from scratch, but it reuses fragments from Prometheus and INGENIAS methodologies for modelling tasks and the ICARO framework for implementation purposes. As VigilAgent intends to automate as much as possible the development process, it exploits. Model transformation techniques are one of the key aspects of the model‐driven development approach. A model‐to‐model transformation is used to facilitate the interoperability between Prometheus and INGENIAS methodologies. Also, a model‐to‐text transformation is performed to generate ICARO code from the INGENIAS model. A case study based on access control is used to illustrate the fundamentals of the model‐to‐model and model‐to‐text transformations implemented in VigilAgent.     

Extending UML to model Web 2.0‐based context‐aware applications

Web 2.0 Mashups offer entirely new opportunities for context‐aware application (CAA) developers by integrating Web 2.0 technologies to facilitate interoperability among heterogeneous context‐aware systems. From a software engineering perspective, a visualized approach for Web 2.0‐based CAA modeling is crucial. Current CAA development, however, cannot provide a conceptual model for Web 2.0‐based CAA. Therefore, the development efficiency and potential for reuse are decreased. The UML is a general purpose modeling language with potential for use in many application domains. However, UML often lacks elements needed to model concepts in specific domains, such as Web 2.0‐based CAA modeling. To address the above issues, this study presents the Web 2.0‐based CAA UML profile, a UML profile for modeling Web 2.0‐based CAA. Copyright © 2011 John Wiley & Sons, Ltd.     

一种WSDL自动生成系统的研究与实现

WSDL是Web Services中的主要协议.WSDL文件的自动生成是建立WebServices应用支持环境中需要解决的关键问题.通过对Java反射机制（Reflection）的应用,建立了一个轻量级的WSDL自动生成工具,对于由Java类来实现业务逻辑的Web Services,能够自动生成该服务对应的WSDL文件,为相关WSDL文件生成系统的设计提供了范例.     

Architecting and implementing distributed Web applications using the graph‐oriented approach

This paper presents a graph‐oriented framework, called WebGOP, for architecture modeling and programming of Web‐based distributed applications. WebGOP is based on the graph‐oriented programming (GOP) model, under which the components of a distributed program are configured as a logical graph and implemented using a set of operations defined over the graph. WebGOP reshapes GOP with a reflective object‐oriented design, which provides powerful architectural support in the World Wide Web environment. In WebGOP, the architecture graph is reified as an explicit object which itself is distributed over the network, providing a graph‐oriented context for the execution of distributed applications. The programmer can specialize the type of graph to represent a particular architecture style tailored for an application. WebGOP also has built‐in support for flexible and dynamic architectures, including both planned and unplanned dynamic reconfiguration of distributed applications. We describe the WebGOP framework, a prototypical implementation of the framework on top of SOAP, and a performance evaluation of the prototype. The prototype demonstrated the feasibility of our approach. Results of the performance evaluation showed that the overhead introduced by WebGOP over SOAP is reasonable and acceptable. Copyright © 2003 John Wiley & Sons, Ltd.     

OPM/Web – Object-Process Methodology for Developing Web Applications

Web applications can be classified as hybrids between hypermedia and information systems. They have a relatively simple distributed architecture from the user viewpoint, but a complex dynamic architecture from the designer viewpoint. They need to respond to operation by an unlimited number of heterogeneously skilled users, address security and privacy concerns, access heterogeneous, up-to-date information sources, and exhibit dynamic behaviors that involve such processes as code transferring. Common system development methods can model some of these aspects, but none of them is sufficient to specify the large spectrum of Web application concepts and requirements. This paper introduces OPM/Web, an extension to the Object-Process Methodology (OPM) that satisfies the functional, structural and behavioral Web-based information system requirements. The main extensions of OPM/Web are adding properties of links to express requirements, such as those related to encryption; extending the zooming and unfolding facilities to increase modularity; cleanly separating declarations and instances of code to model code transferring; and adding global data integrity and control constraints to express dependence or temporal relations among (physically) separate modules. We present a case study that helps evaluate OPM/Web and compare it to an extension of the Unified Modeling Language (UML) for the Web application domain.     

MDA技术在Web服务开发与集成中的应用

模型驱动架构（Model Driven Architecture．MDA）是对象管理集团（OMG）提出的一个新的软件开发框架,它把应用开发的重点由编码转移到更高的抽象层次——模型（元数据）。针对现今Web服务开发模式中存在的问题,讨论了模型驱动架构技术在Web服务开发与集成中的应用,引出开发流程并且提出一个二者结合的模型集成架构,最后使用支持MDA的工具OptimalJ开发与集成了一个Web服务,从实例中分析它们结合的可行性与优势。     

Efficient image‐aware version control systems using GPU

Version control is considered to be a vital component for supporting professional software development. While it has been widely used for textual artifacts, such as source code or documentation, little attention has been given to binary artifacts. This omission can place huge restrictions on projects in the game and media industries as they contain large amounts of binary data, such as images, videos, three‐dimensional models, and animations, along with their source code. For these kinds of artifacts, existing strategies such as storing the file as a whole for each revision or saving conventional binary deltas consume significant storage space with duplicate data and, even worse, do not provide any understandable information on which modifications were made. As a response to this problem, this paper introduces a change‐set model infrastructure to support version control of image artifacts using a specialized data structure. Additionally, our approach can deal with the maintenance of duplicate nearly identical images through a merge operation. Because of the amount of data that has to be processed, we designed our solution based on a parallel architecture, which permits a massively parallel approach to version control. The paper also compares our approach with some popular open‐source version control systems, showing their repository growth in relation to ours as well as the time required to process image artifacts. Finally, we demonstrate that our architecture requires less storage space and runs much faster than current methods. Copyright © 2015 John Wiley & Sons, Ltd.     

Enabling the generation of web applications from mockups

Mockups are widely used to elicit and validate user requirements in web applications, and several intuitive tools have been developed in recent years, actively involving the end user in the requirements solicitation process. However, most current web development approaches and tools discard mockups after the information‐gathering process, abandoning the opportunity to exploit underlying information in them for autogenerating functional web applications. To overcome this limitation, we have devised a method for deriving the database schema and the logic of the web application from the information contained within mockups. In particular, the method gathers clues on how to organize the data and the control flow of the web application by analyzing the structure and relationships of the widgets in the mockup. Based on the proposed method, we have implemented a tool supporting the generation of web applications abiding by the model‐view‐controller architectural pattern. The tool has been evaluated by involving several end users in the development of web applications for different domains.     

模型驱动下的Web应用系统自动生成

为了提高Web应用系统开发效率,提出了模型驱动下的Web应用系统自动生成方法。这种生成方法是以Me—taEdit＋作为元建模工具,首先创建Web应用系统元模型、定制DSL,进而建立Web应用系统领域模型,然后通过MetaEdit＋提供的生成器定义语言MERL,软件开发人员可以很方便地设计出Web应用系统所需的JSP生成器、Servlet生成器、Jayabeans生成器和数据库生成器,从Web应用系统图形模型直接生成整个Web应用系统。最后通过一个WebShopping实例详细介绍了模型驱动下的Web应用系统生成方法及生成过程。经测试,所生成的Web应用系统可以在Windows操作系统中的Web应用服务器上正确运行。     

基于Web服务的网格体系结构及其支撑环境研究

网格技术是当前网络计算的前沿领域,基于Web服务技术构建网格系统有助于提高网格系统的可扩展性和互操作能力,是这一领域中的最新热点.但现有的工作尚未明确界定基于Web服务的网格的功能模型和实现机制.首先讨论了网格功能模型,基于OGSA(open grid service architecture)框架提出了基于Web服务的网格层次体系结构,并将Web服务工作流引入到网格任务描述中,给出一种Web服务与网格技术相融合的机制,介绍了基于Web服务的网格支撑环境WebSASE4G的总体结构和设计原理,为基于Web     

Chameleon – a group communication framework for smartphones

This paper reports about our experience in designing and developing Chameleon, a highly portable and adaptable group communication framework for smartphones. Chameleon owes its level of portability to several design choices, including the following: (i) a layered architecture, where the headers of each layer have a standard XML‐based format, enabling automatic, error‐resistant generation of efficient serialization code in any platform; (ii) reliance only on the J2ME library, which serves as least common denominator for Java dialects and facilitates automatic translation to.NET; (iii) having flexible membership models; and (iv) supporting multiple concurrent protocol stacks.Through a single codebase, Chameleon is currently available as an open‐source project for J2ME, J2SE, Android,.NET CF, and.NET. Chameleon is easily extendable and is bundled with tools, configurations, and third‐party code tuned in a way that lifts some of the burden normally associated with multiplatform development for smartphones. Both the header generation from XML and automatic translation to.NET features of Chameleon are readily available to any application that is based on it. Chameleon's threading model separates between execution of internal layers and application's code and by that protects one from the other. As we describe in the paper, it simplifies layers' development and allows the protocol stack to easily block application calls when this is required by internal algorithms. Additionally, this model simplifies testing, and an extensive testing framework is supplied along with Chameleon, which is also usable for testing of application‐specific layers. Copyright © 2014 John Wiley & Sons, Ltd.