Game engine programming involves a great number of software components, many of which perform similar tasks; for example, memory allocation must take place in the renderer as well as in the creation routines while other tasks such as error logging must take place everywhere. One area of all games which is critical to the success of the game is that of game balance and tuning. These balancing initiatives cut across all areas of code from the player and AI to the mission manager. In computer science, we’ve come to call these types of concerns “cross cutting”. Aspect oriented programming was developed, in part, to solve the problems of cross cutting: employing “advice” which can be incorporated across different pieces of functionality. Yet, despite the prevalence of a solution, very little work has been done to bring cross cutting to game engine programming. Additionally, the discipline involves a heavy amount of code rewriting and reuse while simultaneously relying on many common design patterns that are copied from one project to another. In the case of game balance, the code may be wildly different across two different games despite the fact that similar tasks are being done. These two problems are exacerbated by the fact that almost every game engine has its own custom DSL (domain specific language) unique to that situation. If a DSL could showcase the areas of cross cutting concerns while highlighting the ability to capture design patterns that can be used across games, significant productivity savings could be achieved while simultaneously creating a common thread for discussion of shared problems within the domain. This dissertation sought to do exactly that- create a metalanguage called GAMESPECT which supports multiple styles of DSLs while bringing aspect-oriented programming into the DSL’s to make them DSAL (domain specific aspect languages). The example cross cutting concern was game balance and tuning since it’s so pervasive and important to gaming. We have created GAMESPECT as a language and a composition framework which can assist engine developers and game designers in balancing their games, forming one central place for game balancing concerns even while these concerns may cross different languages and locations inside the source code. Generality was measured by showcasing the composition specifications in multiple contexts and languages. In addition to evaluating generality and performance metrics, effectiveness was be measured. Specifically, comparisons were made between a balancing initiative when performed with GAMESPECT vs a traditional methodology. In doing so, this work shows a clear advantage to using a Metalanguage such as GAMESPECT for this task. In general, a line of code reduction of 9-40% per task was achieved with negligible effects to performance. The use of a metalanguage in Unreal Engine 4 is a starting point to further discussions concerning other game engines. In addition, this work has implications beyond video game programming. The work described highlights benefits which might be achieved in other disciplines where design pattern implementations and cross-cutting concern usage is high; the real time simulation field and the field of Windows GUI programming are two examples of future domains.

No description available.

<p>The set of related products is referred to as a product family, and feature-modeling is a widely used technique to capture the commonalities and variabilities of a product family in terms of "features". With the growing complexity of software product families in several software industries, the development, maintenance and evolution of complex and large feature models are among the main challenges faced by feature-modeling practitioners. In particular, more sophisticated feature-modeling techniques are required to address the problems caused by unanticipated changes and crosscutting concerns in feature models.</p> <p>This thesis tackles the above challenges in feature-modeling by adopting the aspect-oriented paradigm at the feature-modeling level. I first introduce a specification language, called AO-PFA, which is an extension of the Product Family Algebra (PFA) language. I then proposed a formal verification technique to check the compatibility of aspects with their base specifications in AO-PFA. In the aspect-oriented paradigm, the process of combining aspects with base specifications is referred to as the weaving process. I finally discussed how to perform the weaving process in AO-PFA. By proposing a systematic approach to extend product family algebra with the abilities of specifying, verifying, and weaving aspects, we are able to handle the difficulties that arise from crosscutting concerns and unanticipated changes in large-scale feature models.</p> / Doctor of Philosophy (PhD)

Modern distributed object systems pass remote parameters based on their runtime type. This design choice limits the expressiveness, readability, and maintainability of distributed applications. While a rich body of research is concerned with middleware extensibility, modern distributed object systems do not offer programming facilities to extend their remote parameter passing semantics. Thus, extending these semantics requires understanding and modifying the underlying middleware implementation. This thesis addresses these design shortcomings by presenting (i) a declarative and extensible approach to remote parameter passing that decouples parameter passing from parameter types, and (ii) a plugin-based framework, DeXteR, that enables the programmer to extend the native set of remote parameter passing semantics, without having to understand or modify the underlying middleware implementation. DeXteR treats remote parameter passing as a distributed cross-cutting concern. It uses generative and aspect-oriented techniques, enabling the implementation of different parameter passing semantics as reusable application-level plugins that work with application, system, and third-party library classes. The flexibility and expressiveness of the framework is validated by implementing several non-trivial parameter passing semantics as DeXteR plugins. The material presented in this thesis has been accepted for publication at the ACM/USENIX Middleware 2008 conference. / Master of Science

Uma abordagem de teste estrutural de integração par-a-par para programas OO e OA escritos em Java e AspectJ é apresentada. A finalidade dessa abordagem é descobrir defeitos que possam existir na interface entre os pares de unidades que se relacionam em um programa. Para programas OO este tipo de teste envolve testar a interação entre os pares de métodos. Já para programas OA, o teste estrutural de integração par-a-par envolve testar a interação entre os seguintes pares de unidades: método-método, método-adendo, adendo-método e adendo-adendo. Para efetuar o teste estrutural de integração par-a-par deve-se considerar todo o fluxo de execução (fluxo de controle e de dados) que ocorre entre a unidade chamadora e a unidade chamada. Para isso é definido o grafo Def-Uso Par-a-Par (PWDU) que é uma abstração formada pela integração dos grafos Def-Uso Orientado a Aspectos (AODU) da unidade chamadora e da unidade chamada. Além disso, são propostos três critérios para derivar requisitos de teste para pares de unidades. Dentre eles, dois critérios são baseados em fluxo de controle: todos-nós-integrados e todas-arestas-integradas; e um critério é baseado em fluxo de dados: todos-usos-integrados. Uma ferramenta que apóia o teste estrutural de unidade de programas OO e OA escritos em Java e AspectJ, chamada JaBUTi/AJ, foi estendida para dar apoio à abordagem de teste de integração proposta. Exemplos de usos são discutidos para explicar a aplicação da abordagem / A pairwise integration structural testing approach for OO and AO programs implemented with Java and AspectJ is presented. The purpose of this approach is to find faults that may exist in the interface between the pairs of units that relate in a program. For OO programs this type of testing involves testing the interaction among pair of methods. For AO programs, the pairwise integration structural testing involves testing the interaction among the following pairs of units: method-method, method-advice, advice-method and advice-advice. To perform the pairwise integration structural testing, all the execution flow (control and data flow) that happens between the caller and the called unit must be considered. For this, it is defined the PairWise Def-Use graph (PWDU) that is an abstraction formed by the integration of the Aspect-Oriented Def-Use (AODU) graphs of the caller and called unit. Additionally, three new criteria to derive test requirements for pairs of units are proposed. Amongst them, two criteria are based on control flow: all-integrated-nodes and all-integrated-edges; and one criterion is based on data flow: all-integrated-uses. A tool that supports unit structural testing of OO and AO programs implemented with Java and AspectJ, called JaBUTi/AJ, was extended in order to support the proposed integration testing approach. Examples are discussed in order to explain the application of the approach

A Programação Orientada a Aspectos (POA) é uma técnica de desenvolvimento que apoia a separação de interesses transversais. Na POA, adendos são aplicados a pontos de junção do sistema por meio de uma construção especial chamada descritor de conjuntos de junção (ou simplesmente conjunto de junção). Esse mecanismo apoia a modularização de comportamentos transversais, entretanto, como as interações adicionadas não ficam explícitas no código-fonte, é difícil assegurar que estão corretas. Para lidar com esse problema, nesta tese é proposta uma abordagem rigorosa de teste estrutural de integração para programas orientados a aspectos. É definido um modelo de fluxo de controle e de dados baseado no bytecode Java chamado Grafo Def-Uso baseado em conjuntos de junção (ou PointCut-based Def-Use graph, PCDU) que modela as regiões de execução de um programa escrito em AspectJ que são afetadas por um conjunto de junção. Sobre este modelo são definidos três critérios de teste: todos-nós-baseados-em-conjunto-de-junção, todas-arestas-baseadas-em-conjunto-de-junção e todos-usos-baseados-em-conjunto-de-junção, que requerem a cobertura de todos os comandos, condicionais e pares def-uso no contexto de cada ponto de junção selecionado. Para automatizar o uso do modelo e critérios propostos, é implementada uma ferramenta chamada JaBUTi/PC-AJ. Além disso, para validar a abordagem proposta, são conduzidos estudos teóricos e experimentais que procuram avaliar os critérios tanto do ponto de vista do custo de aplicação quanto do ponto de vista da eficácia em encontrar defeitos. Os estudos oferecem indícios da aplicabilidade e da eficácia dos critérios para encontrar defeitos diretamente relacionados com a POA / Aspect-Oriented Programming (AOP) is a promising development technique that supports separation of crosscutting concerns. In AOP, advice is applied to join points in the system through a special construct called pointcut. This mechanism supports the modularization of crosscutting behavior; however, since the added interactions are not explicit in the source code, it is hard to ensure their correctness. To tackle this problem, this thesis proposes a rigorous structural testing approach for aspect-oriented programs. A control and data flow model based on Java bytecode the PointCut-based Def-Use Graph (PCDU) that models execution regions of a program affected by a pointcut is proposed. On top of this model three testing criteria are defined: all-pointcut-based-advice-nodes, all-pointcut-based-advice-edges, and all-pointcut-based-advice-uses, that require exercising all statements, branches and def-use pairs of each advice at the context of each affected join point. To automate the use of the proposed model and criteria, a tool named JaBUTi/PC-AJ is implemented. Moreover, to validate the proposed approach, both theoretical and experimental studies are presented. These studies provide evidence of the applicability and efficacy of the proposed criteria

A Programação Orientada a Aspectos (POA) é uma técnica de desenvolvimento que apoia a separação de interesses transversais. Na POA, adendos são aplicados a pontos de junção do sistema por meio de uma construção especial chamada descritor de conjuntos de junção (ou simplesmente conjunto de junção). Esse mecanismo apoia a modularização de comportamentos transversais, entretanto, como as interações adicionadas não ficam explícitas no código-fonte, é difícil assegurar que estão corretas. Para lidar com esse problema, nesta tese é proposta uma abordagem rigorosa de teste estrutural de integração para programas orientados a aspectos. É definido um modelo de fluxo de controle e de dados baseado no bytecode Java chamado Grafo Def-Uso baseado em conjuntos de junção (ou PointCut-based Def-Use graph, PCDU) que modela as regiões de execução de um programa escrito em AspectJ que são afetadas por um conjunto de junção. Sobre este modelo são definidos três critérios de teste: todos-nós-baseados-em-conjunto-de-junção, todas-arestas-baseadas-em-conjunto-de-junção e todos-usos-baseados-em-conjunto-de-junção, que requerem a cobertura de todos os comandos, condicionais e pares def-uso no contexto de cada ponto de junção selecionado. Para automatizar o uso do modelo e critérios propostos, é implementada uma ferramenta chamada JaBUTi/PC-AJ. Além disso, para validar a abordagem proposta, são conduzidos estudos teóricos e experimentais que procuram avaliar os critérios tanto do ponto de vista do custo de aplicação quanto do ponto de vista da eficácia em encontrar defeitos. Os estudos oferecem indícios da aplicabilidade e da eficácia dos critérios para encontrar defeitos diretamente relacionados com a POA / Aspect-Oriented Programming (AOP) is a promising development technique that supports separation of crosscutting concerns. In AOP, advice is applied to join points in the system through a special construct called pointcut. This mechanism supports the modularization of crosscutting behavior; however, since the added interactions are not explicit in the source code, it is hard to ensure their correctness. To tackle this problem, this thesis proposes a rigorous structural testing approach for aspect-oriented programs. A control and data flow model based on Java bytecode the PointCut-based Def-Use Graph (PCDU) that models execution regions of a program affected by a pointcut is proposed. On top of this model three testing criteria are defined: all-pointcut-based-advice-nodes, all-pointcut-based-advice-edges, and all-pointcut-based-advice-uses, that require exercising all statements, branches and def-use pairs of each advice at the context of each affected join point. To automate the use of the proposed model and criteria, a tool named JaBUTi/PC-AJ is implemented. Moreover, to validate the proposed approach, both theoretical and experimental studies are presented. These studies provide evidence of the applicability and efficacy of the proposed criteria

Uma abordagem de teste estrutural de integração contextual para programas OO e OA escritos em Java e AspectJ é apresentada. A finalidade dessa abordagem é descobrir defeitos que possam existir nas interfaces entre uma determinada unidade (método ou adendo) e todas as outras que interagem diretamente com ela, bem como descobrir defeitos que possam ocorrer na hierarquia de chamadas dessas unidades. Para programas OO, esse tipo de teste envolve testar a interação entre métodos; já para programas OA, o teste estrutural de integração nível um (como também pode ser chamado) deve considerar as interações método-método, método-adendo, adendo-adendo e adendo-método. Para efetuar o teste estrutural de integração nível um deve-se considerar todo o fluxo de execução (fluxo de controle e de dados) que ocorre entre uma unidade chamadora e as unidades que interagem diretamente com ela. Para isso é definido o grafo Def-Uso IN1P, que é uma abstração formada pela integração dos grafos Def-Uso Orientado a Aspectos (AODU) da unidade chamadora e das unidades que ela chama ou que a afeta. Além disso, são propostos três critérios para derivar os requisitos de teste, dois baseados em fluxo de controle (todos-nós-integrados-N1 e todas-arestas-integradas-N1) e um baseado em fluxo de dados (todos-usos-integrados-N1). A ferramenta JaBUTi/AJ foi estendida para dar apoio à abordagem de teste de integração proposta. Exemplos são apresentados para ilustrar o uso da ferramenta para o teste de profundidade um e também seu uso no contexto de uma abordagem que leva em consideração também o teste de unidades e o teste baseado em conjuntos de junção / A Contextual structural integration testing for OO and OA programs written in Java and AspectJ is presented. The purpose of this approach is to discover faults that may exist in the interfaces between a particular unit (method or advice) and all others that interact directly with it, as well as to discover defects that may occur in the call hierarchy of these units. In OO programs, this type of test involves testing the interaction among methods. For OA programs, the structural integration testing at the depth of one (as it can also be called) should consider the method-method, method-advice, advice-advice and advice-method interactions. To perform structural integration testing at the depth of one level the whole execution flow (control and data flow) that occurs among a caller unit and the units that interact directly with it it must be considered. The IN1P Def-Use graph has been defined as an abstraction formed by the integration of the Aspect-Oriented Def-Use (AODU) graphs of the caller unit and of the units that it calls or affects it. Also, three criteria to derive test requirements are proposed, two of which are based on control flow all-integrated-nodes-N1 and all-integrated-edges-N1 and one is based on data flowall-integrated-uses-N1. The tool JaBUTi/AJ was extended to support the proposed integration testing approach. Examples are presented to illustrate the use of the tool for depth 1 testing as well as its use in the context of an approach that also takes into account unit testing and pointcut-based testing

"The essence of software design is to construct well-defined, encapsulated modules that are composed together to build the desired software application. There are several design paradigms in use today, including traditional Object-Oriented Programming (OOP), Feature-Oriented Programming (FOP), Aspect-Oriented Programming (AOP) and Instance-Oriented Programming (IOP). FOP studies the modularity of features in product lines, where a feature is an increment in program functionality. AOP aims to separate and modularize aspects when an aspect is a crosscutting concern. IOP, as an extension to FOP, makes the layers work like object factories. While each is good at solving different types of problems, they are closely related. The composition of modules is complicated because modules have (often hidden) dependencies on other modules. This thesis aims to better understand the way dependencies are managed by each approach. Based on this, we focus on the precedence issue in AOP and FOP, that is, how designers are able to specify the order by which modules are composed together. Different precedence means different semantics, but the current tools can not guarantee the correct precedence is adopted. We first solve the precedence issue separately for AOP and FOP, then based on this, we come up with a unified model to solve the precedence issue by using source code annotations to specify the precedence. We evaluate our technique with use cases. "

Made available in DSpace on 2014-12-17T15:47:52Z (GMT). No. of bitstreams: 1 EvertonTG_DISSERT.pdf: 4234791 bytes, checksum: c40151c48849ad62c0cc34be8c3b56eb (MD5) Previous issue date: 2010-03-04 / Currently there are several aspect-oriented approaches that are related to different stages of software development process. These approaches often lack integration with each other and their models and artifacts are not aligned in a coherent process. The integration of Aspect-Oriented Software development (AOSD) and Model-Driven Development (MDD) enables automatic propagation of models from one phase to another, avoiding loss of important information and decisions established in each. This paper presents a model driven approach, called Marisa-AOCode, which supports the processing of detailed design artifacts to code in different Aspect-Oriented Programming languages. The approach proposed by Maris- AOCode defines transformation rules between aSideML, a modeling language for aspectoriented detailed design, and Metaspin, a generic metamodel for aspect-oriented programming languages. The instantiation of the generic metamodel (Metaspin) provided by the approach of Maris-AOCode is illustrated by the transformation of Metaspin for two languages: AspectLua and CaesarJ. We illustrate the approach with a case study based on the Health Watcher System / Atualmente existem diversas abordagens orientadas a aspectos que est?o relacionadas ?s diferentes fases do processo de desenvolvimento de software. Essas abordagens geralmente n?o possuem integra??o entre si e seus modelos e artefatos n?o est?o alinhados dentro de um processo coerente. A integra??o entre o desenvolvimento de software orientado a aspectos (DSOA) e o desenvolvimento dirigido a modelos (MDD) permite propaga??o autom?tica entre modelos de uma fase para outra, evitando perda de informa??es e decis?es importantes estabelecidas em cada uma delas. Este trabalho apresenta uma abordagem dirigida a modelos, denominada MaRiSA-AOCode, que suporta a transforma??o de artefatos de projeto detalhado em c?digo para diferentes linguagens de Programa??o Orientada a Aspectos. A abordagem proposta por MaRiSA-AOCode define regras de transforma??o entre aSideML, uma linguagem de modelagem para projeto detalhado orientado a aspectos, e Metaspin, um metamodelo gen?rico para linguagens de programa??o orientadas a aspectos. A instancia??o do metamodelo gen?rico (Metaspin) provido pela abordagem de MaRiSA-AOCode ? ilustrada atrav?s da transforma??o do Metaspin para duas linguagens: AspectLua e CaesarJ. Ilustramos a abordagem com um estudo de caso baseado no sistema Health Watcher