Victor Guana | University of Alberta (original) (raw)

Papers by Victor Guana

Proceedings of the first ACM SIGCHI annual symposium on Computer-human interaction in play - CHI PLAY '14, 2014

Educational serious games are effective tools to communicate topics of interest to diverse audien... more Educational serious games are effective tools to communicate topics of interest to diverse audiences through well defined gameplay designs. In recent years, reproductive health has become an area of special interest for government and health organizations when designing educational programs for teens and young adults. In this paper we present UnderControl, a multi-level mobile serious game that educates players about contraception and STI prevention in an elegant, yet straightforward fashion.

Serious games are proposed as a more efficient and enjoyable way to carry out cognitive assessmen... more Serious games are proposed as a more efficient and enjoyable way to carry out cognitive assessment. We compare prediction of cognitive ability with a purpose-built serious game and with a similar game built using a game engine. In an experiment conducted with 28 participants, performance on the two games is assessed relative to three cognitive abilities, using two different tablet sizes and two different input methods. The results for the game-engine variant were similar to the purpose-built game, where both games significantly predicted performance on the three cognitive abilities, and were sensitive to the effects of age. Performance on both games was not significantly affected by tablet size or input method. These results support earlier findings that serious games can provide valid cognitive assessment, and they show that game engines can be used to develop serious games for cognitive assessment, cost effectively and without loss of predictive validity.

Model-based code-generators are complex in nature; they are built using diverse technology platfo... more Model-based code-generators are complex in nature; they are built using diverse technology platforms such as language workbenches, and model-to-model and model-to-text transformation languages. Due to the highly heterogeneous technology ecosystem in which code generators are built, understanding and maintaining their architecture pose numerous cognitive challenges to both novice and expert developers. Most of these challenges are associated with tasks that require to trace and pinpoint generation artifacts given a life-cycle requirement. We argue that such tasks can be classified in three families, namely, 1. information discovery, 2. information summarization, and 3. information filtering and isolation. Furthermore, we hypothesize that visualizations that allow the interactive exploration of model-to-model and model-to-text transformation compositions can significantly improve developers’ performance when reflecting on a code generation architecture, and its corresponding execution mechanics. In this paper we describe an empirical study which purpose is twofold: first to (a) understand the performance of developers (in terms of time and precision) when asked to discover, filter, and summarize information about a model-based code generator, using classic integrated development environments and editors, and to (b) measure and compare the performance of developers executing the same set of tasks using state-of-theart traceability visualizations for model-transformation compositions

Model-based code generators use model-to-model and model-to-text transformations to systematize t... more Model-based code generators use model-to-model and model-to-text transformations to systematize the construction of software systems. They integrate rule-based and template-based transformation languages to translate high-level specifications into executable code and scripts. Given the complexity and heterogeneity of the underlying transformation languages, flexible traceability tools are needed to collect and visualize information about their architecture and operational mechanics. In this paper,we present ChainTracker, a traceability analysis environment for model-based code generators. ChainTracker helps developers to reflect on the composition of model transformations during the different stages of their construction and maintenance. Furthermore, in this paper we describe a family of software-engineering tasks that developers have to complete during the construction of model-based code generators, and how ChainTracker makes the execution of these.

Game-construction engines enable developers to reuse assets from previously developed games, thus... more Game-construction engines enable developers to reuse assets from previously developed games, thus easing the software-engineering challenges around the video-game development experience and making the implementation of games less expensive, less technologically brittle, and more efficient. However, the construction of game engines is challenging in itself; it involves the specification of well defined architectures and typical gameplay behaviors, flexible enough to enable game designers to implement their vision, while, at the same time, simplifying the implementation through asset and code reuse. In this paper we present a set of lessons learned through the design and construction PhyDSL-2, a game engine for 2D physics-based games. Our experience involves the active use of modern model-driven engineering technologies, to overcome the complexity of the engine design and to systematize its maintenance and evolution.

Code-generation environments have emerged as a new mechanism for building software systems in a s... more Code-generation environments have emerged as a new mechanism for building software systems in a systematic manner. At their core, model-driven engineering technologies such as model-to-model and model-to-text transformations are effectively used to build generation engines. However, due to the complexity of model-to-model and model-to-text transformation scripts, which is exacerbated as they are composed in complex transformation chains, developers face technical and cognitive challenges when architecting, implementing, and maintaining code-generation environments. In this paper we present ChainTracker, a visualization and trace analysis tool for model-to-model and model-to-text transformation compositions. ChainTracker aims to support developers of code-generation environments by making the usage of model-driven engineering technologies more efficient, less error prone, and less cognitively challenging.

Video-game design and development involves a variety of professionals working together to create ... more Video-game design and development involves a variety of professionals working together to create games with engaging content, and an efficient and flexible software architecture. However, more often than not, video-game development environments are designed for software developers, supporting programming tasks agnostic of the needs of the non-computer experts on the team. Code-generation environments offer an alternative methodology to building families of software systems that systematically differ from each other. They provide high-level domain-specific languages that express the domain concepts and features of interest, and isolate the low-level implementation concerns, so that even non-programming experts can prototype and efficiently create software systems. In this paper we describe PhyDSL, a code-generation environment for the creation of mobile physics-based games in 2D. We report how we have used PhyDSL for the rapid prototyping of customizable and cost effective games based on physics.

7th International Conference on Model Transformation, ICMT 2014, 2014

Model-driven engineering is advocated as an effective method for developing families of software ... more Model-driven engineering is advocated as an effective method for developing families of software systems that systematically differ across well defined dimensions. Yet, this software construction paradigm is rather brittle at the face of evolution. Particularly, when building code-generation environments, platform evolution scenarios force developers to modify the generated code of individual generation instances in an ad-hoc manner. Thus violating the systematicity of the original construction process. In order to maintain the code-generation environment synchronized, code refinements have to be traced and backwardly propagated to generation infrastructure so as to make these changes systematically possible for all systems that can be generated. This paper presents ChainTracker, a general conceptual framework, and model-transformation composition analysis tool that supports developers when maintaining and synchronizing re ned code-generation environments. ChainTracker gathers and visualizes model-to-model, and model-to-text traceability information for ATL and Acceleo model-transformation compositions.

Center for Advanced Studies on Collaborative Research, CASCON '13, Nov 28, 2013

In this paper we present an empirical study on the refactoring activity in three well-known proje... more In this paper we present an empirical study on the refactoring activity in three well-known projects. We have studied five research questions that explore the different types of refactorings applied to different types of sources, the individual contribution of team members on refactoring activities, the alignment of refactoring activity with release dates and testing periods, and the motivation behind the applied refactorings. The studied projects have a history of 12, 7, and 6 years, respectively.We have found that there is very little variation in the types of refactorings applied on test code, since the majority of the refactorings focus on the reorganization and renaming of classes. Additionally, we have identified that the refactoring decision making and application is often performed by individual refactoring ``managers''. We have found a strong alignment between refactoring activity and release dates. Moreover, we found that the development teams apply a considerable amount of refactorings during testing periods. Finally, we have also found that in addition to code smell resolution the main drivers for applying refactorings are the introduction of extension points, and the resolution of backward compatibility issues.

TEFSE'13 - The 7th International Workshop on Traceability in Emerging Forms of Software Engineering.

Transformational code generation is at the core of generative software development. It advocates ... more Transformational code generation is at the core of generative software development. It advocates the detection of common and variable features in families of software systems that can be generalized and modeled by domain-specific languages. Additionally, it proposes transformation compositions as a means for successively refining the abstraction level of domain models towards eventually enriching them with execution semantics. Thus, using code-generation environments, families of software systems can be generated, based on models specified in high-level domain languages. The major advantage of this software-construction methodology stems from the fact that it enables the reuse of verified execution semantics, derived from domain models. However, like all software, once an implementation is generated, it is bound to evolve and manually refined to introduce features that were not captured by its original generation environment. This paper describes a conceptual framework for identifying features that have to be backwards propagated to generation engines, from refined generated references. Our conceptual framework is based on static and symbolic execution analysis, and aims to contribute to the maintenance and evolution challenges of model-driven development.

Doctoral Symposium 35th International Conference on Software Engineering (ICSE 2013)

At the core of model-driven software development, model-transformation compositions enable automa... more At the core of model-driven software development, model-transformation compositions enable automatic generation of executable artifacts from models. Although the advantages of transformational software development have been explored by numerous academics and industry practitioners, adoption of the paradigm continues to be slow, and limited to specific domains.The main challenge to adoption is the fact that maintenance tasks, such as analysis and management of model-transformation compositions and reflecting code changes to model transformations, are still largely unsupported by tools. My dissertation aims at enhancing the field’s understanding around the maintenance issues in transformational software development, and at supporting the tasks involved in the synchronization of evolving system features with their generation environments. This paper discusses the three main aspects of the envisioned thesis: (a) complexity analysis of model-transformation compositions, (b) system feature localization and tracking in model-transformation compositions, and (c) refactoring of transformation compositions to improve their qualities.

MoMM '11 Proceedings of the 9th International Conference on Advances in Mobile Computing and Multimedia, Jan 1, 2011

In a competitive world where enterprises have to continually release new and better services, the... more In a competitive world where enterprises have to continually release new and better services, there is a constant need to assimilate new capabilities and extend software applications functionalities. Nowadays these requirements have been translated into mobile environments, making the extension of mobile applications a challenge from the scalability perspective. In this paper, a mobile and flexible software architecture is presented. It allows the integration of third party mobile services to the developed platform, making the extension of a mobile application a dynamic task. By doing so, users can consume a service from their mobile devices through a dynamic user interface. This flexible architecture permits the aggregation of services without having to modify the mobile system, and therefore, it increases the application scalability and practicality in terms of its deployment and maintenance.

Journal of Information and Software Technology, Jan 1, 2012

Context: During the definition of software product lines (SPLs) it is necessary to choose the com... more Context: During the definition of software product lines (SPLs) it is necessary to choose the components that appropriately fulfil a product’s intended functionalities, including its quality requirements (i.e., security, performance, scalability). The selection of the appropriate set of assets from many possible combinations is usually done manually, turning this process into a complex, time-consuming, and error-prone task. Objective:
Our main objective is to determine whether, with the use of modeling tools, we can simplify and automate the definition process of a SPL, improving the selection process of reusable assets. Method: We developed a model-driven strategy based on the identification of critical points (sensitivity points) inside the SPL architecture. This strategy automatically selects the components that appropriately match the product’s functional and quality requirements. We validated our approach experimenting with different real configuration and derivation scenarios in a mobile healthcare SPL where we have worked during the last three years. Results: Through our SPL experiment, we established that our approach improved in nearly 98% the selection of reusable assets when compared with the unassisted analysis selection. However, using our approach there is an increment in the time required for the configuration corresponding to the learning curve of the proposed tools. Conclusion: We can conclude that our domain-specific modeling approach significantly improves the software architect’s decision making when selecting the most suitable combinations of reusable components in the context of a SPL.

This document presents the implementation, experimental design, and resulting analysis for the co... more This document presents the implementation, experimental design, and resulting analysis for the comparison of three different implementations of an Inverted Index algorithm. Specifically, we compare data parallel implementations supported using the MapReduce programming framework over two different ecosystems for parallel computation; Hadoop, and MPI. In the inverted index algorithm context, results from our prototypes show that Hadoop implementations perform considerably better than implementations done using MPI with respect to overall execution time. We have tested both strategies using two main datasets that differ in word density and size. In all the experiments, we found a clear tendency on the better overall performance of our Hadoop implementations in comparisons with our MPI implementations. Furthermore, we have found different patterns in terms of network activity and required hard drive resources between both approaches. Our analysis, experimental conditions, and implementation caveats are summarized in the following report. * with the assistance of Afsaneh Esteki, Anahita Alipour, and Mohammad Salameh

Proceedings of the 15th International Conference on Software Product Lines, Jan 1, 2011

Quality assurance and evaluation in Model Driven Software Product Lines (MD-SPLs) are pivotal poi... more Quality assurance and evaluation in Model Driven Software Product Lines (MD-SPLs) are pivotal points for the growing and solidification of the generative software factories. They are framed as one of the future fact methodologies for the construction of software systems. Although several approximations address the problem of generative environments, software product line scope expression, and core asset definition, not many of them try to solve, as a fundamental step, the automation of the quality attribute evaluation in the MD-SPL development cycle. This paper presents a model-driven engineering method and a tool for the quality evaluation of product line configurations through a cross architectural view analysis.

… (MSR), 2012 9th IEEE …, Jan 1, 2012

In this paper we mine the Android bug tracker repository and study the characteristics of the arc... more In this paper we mine the Android bug tracker repository and study the characteristics of the architectural layers of the Android system. We have identified the locality of the Android bugs in the architectural layers of the its infrastructure, and analysed the bug lifetime patterns in each one of them. Additionally, we mined the bug tracker reporters and classified them according to its social centrality in the Android bug tracker community. We report three interesting findings, firstly while some architectural layers have a diverse interaction of people, attracting not only non-central reporters but highly important ones, other layers are mostly captivating for peripheral actors. Second, we exposed that even the bug lifetime is similar across the architectural layers, some of them have higher bug density and differential percentages of unsolved bugs. Finally, comparing the popularity distribution between layers, we have identified one particular layer that is more important to developers and users alike.

Advances in Network Analysis and its Applications, Mathematics in Industry Series. Springer

Social-networking sites are becoming increasingly popular with users of all ages. With much of ou... more Social-networking sites are becoming increasingly popular with users of all ages. With much of our social activity happening online, these sites are now becoming the subject of scholarly study and research. Unfortunately, despite the fact that they collect similar content and support similar relations and activities, the current generation of these sites are hard to query programmatically, offering limited views of their data, effectively becoming disconnected islands of information. We describe SociQL, a high-level query language, and a corresponding service, to which social-networking sites can subscribe, that supports the integrated representation, querying and exploration of disparate social networks. Unlike generic web query languages, SociQL is designed specifically to support the integration of networks through a common information model for the purpose of examining sociological questions, motivated by social theories. The paper discusses the design and rationale for the SociQL language elements and syntax, as well as our experience using the SociQL service to query a variety of social-network sites.