DESIGN PATTERN PADA ASPECT ORIENTED PROGRAMMING DESIGN PATTERN IN ASPECT ORIENTED PROGRAMMING

ABSTRAKSI: Pemrograman berorientasi objek sangat popular dalam dunia rekayasa perangkat lunak, karena dapat mengurangi kompleksitas dalam pemrograman. Masalah yang muncul adalah jika dalam suatu objek atau kelas terdapat suatu aspek yang unik, dan tidak dapat dienkapsulasi menjadi satu objek, atau yang biasa dikenal dengan crosscutting concern. Hal ini dapat menyebabkan modularitas menjadi tidak bersih. Permasalahan lain yang terjadi adalah tentang desain pemrograman berorientasi objek yang harus menangani permasalahan yang muncul secara berulang-ulang, sehingga perlu dicari solusi umum untuk mengatasi permasalahan tersebut.Dalam kasus ini, penulis menerapkan implementasi dari design pattern pada aspect-oriented programming (AOP), yang mana AOP sendiri dibangun berdasarkan object-oriented programming (OOP). Namun satu hal yang berbeda bahwa AOP menjanjikan suatu kemampuan dalam hal melokalisir kode (biasa disebut sebagai alat modularizing crosscutting), yang tidak terdapat dalam OOP. Sedangkan design pattern menawarkan sebuah solusi yang flexibel dalam masalah pengembangan perangkat lunak, yaitu mendukung adanya penggunaan kembali pendekatan dan teknik yang sudah terbukti. Sehingga bila kedua hal ini digabungkan, maka dapat mengurangi kedua permasalahan yang terjadi.Untuk pengembangan design pattern pada AOP ini diimplementasikan dalam AspectJ. AspectJ merupakan perluasan dari aspect-oriented extension pada Java, yang berarti bahwa pemrograman pada AspectJ itu sama saja dengan pemrograman dalam Java dalam aspek yang lebih.Kata Kunci : aspectj, aspect-oriented extension, aspect-oriented programming,ABSTRACT: Design Pattern represents a general solution to internal issues in certain contexts, supporting proven techniques and approaches. Design Pattern offers solutions which are flexibel to be used in solving problems of software development.In this case, writer apply implementation from design pattern of aspectoriented programming (AOP), where AOP itself was developed from objectoriented programming (OOP). One difference is AOP promise an ability in the case of localizing code (usually referred to means of modularizing crosscutting), which is not there in OOP.For development of design Pattern at AOP is implemented by Aspectj. Aspectj is a represent extension from aspect-oriented extension for Java, which means that programming at AspectJ the same with programming in Java in more aspect.Keyword: aspectj, aspect-oriented extension, aspect-oriented programming

A domain-specific aspect language for transforming MATLAB programs

Aspect-oriented programming provides powerful ways to augment programs with information out of the scope of the base language while avoiding harming code readability and thus portability. MATLAB is a popular modeling/programming language that will strongly benefit of aspect-oriented programming features. For instance, MATLAB programmers could use aspects to provide information such as restrictions on allowed data types and/or values, monitoring specific aspects of the execution such as the effective dataset sizes or if a given variable ever assumes a specific value, without “polluting” the code with “check code”. This paper describes the main concepts of a domain-specific aspect language (DSAL) for specifying transformations of MATLAB programs in view of supporting optimizations by facilitating the experimentation of alternative implementations. This DSAL specifies aspect modules structured in three sections: intersections equivalent to AspectJ poincuts, actions equivalent to AspectJ advice, and conditions that control triggering of actions. Support for aspect composition strategies and aspect parameterization of tokens from the base program are also supported. We believe the described features complement and enhance MATLAB programming in substantial and valuable ways

Pluggable AOP: Designing Aspect Mechanisms for Third-party Composition

Studies of Aspect-Oriented Programming (AOP) usually focus on a language in which a specific aspect extension is integrated with a base language. Languages specified in this manner have a fixed, non-extensible AOP functionality. In this paper we consider the more general case of integrating a base language with a set of domain specific third-party aspect extensions for that language. We present a general mixin-based method for implementing aspect extensions in such a way that multiple, independently developed, dynamic aspect extensions can be subject to third-party composition and work collaboratively

An empirical study of aspect-oriented metrics

Metrics for aspect-oriented software have been proposed and used to investigate the benefits and the disadvantages of crosscutting concerns modularisation. Some of these metrics have not been rigorously defined nor analytically evaluated. Also, there are few empirical data showing typical values of these metrics in aspect-oriented software. In this paper, we provide rigorous definitions, usage guidelines, analytical evaluation, and empirical data from ten open source projects, determining the value of six metrics for aspect-oriented software (lines of code, weighted operations in module, depth of inheritance tree, number of children, crosscutting degree of an aspect, and coupling on advice execution). We discuss how each of these metrics can be used to identify shortcomings in existing aspect-oriented software. (C) 2012 Elsevier B.V. All rights reserved.CNPq [140046/06-2]; Project CNPQ-PROSUL [490478/06-9]; Capes-Grices [2051-05-2]; FAPERGS [10/0470-1]; FCT MCTESinfo:eu-repo/semantics/publishedVersio

AspectH: Uma Extensão Orientada a Aspectos de Haskel

This paper presents an extension of the Haskell programming language with the objective of improving modularization of functional programs. This extension, AspectH, extends Haskell with aspect oriented concepts. AspectH implements Aspect-Oriented Programming (AOP) through pointcuts and advice, like in AspectJ, and was designed to be used in Haskell programs that use monads. Keywords: Aspect-oriented programming, functional programming, Haskell, monadsEste artigo apresenta uma extensão da linguagem de programação Haskell com o objetivo de melhorar a modularização de programas funcionais. Esta extensão, chamada AspectH, estende Haskell com conceitos de orientação a aspectos. AspectH implementa Programação Orientada a Aspectos (AOP) através de pointcuts e advice, como em AspectJ, e foi projetada para atuar em programas Haskell que utilizam mônadas. Palavras-chave: Programação orientada a aspectos, programação funcional, Haskell, mônadas

A Systematic Aspect-Oriented Refactoring and Testing Strategy, and its Application to JHotDraw

Aspect oriented programming aims at achieving better modularization for a system's crosscutting concerns in order to improve its key quality attributes, such as evolvability and reusability. Consequently, the adoption of aspect-oriented techniques in existing (legacy) software systems is of interest to remediate software aging. The refactoring of existing systems to employ aspect-orientation will be considerably eased by a systematic approach that will ensure a safe and consistent migration. In this paper, we propose a refactoring and testing strategy that supports such an approach and consider issues of behavior conservation and (incremental) integration of the aspect-oriented solution with the original system. The strategy is applied to the JHotDraw open source project and illustrated on a group of selected concerns. Finally, we abstract from the case study and present a number of generic refactorings which contribute to an incremental aspect-oriented refactoring process and associate particular types of crosscutting concerns to the model and features of the employed aspect language. The contributions of this paper are both in the area of supporting migration towards aspect-oriented solutions and supporting the development of aspect languages that are better suited for such migrations.Comment: 25 page