Modular software design with crosscutting interfaces

Griswold, William G.; Shonle, Macneil; Sullivan, Kevin; Tewari, Nishit; Cai, Yuanfang; Rajan, Hridesh

doi:10.1109/ms.2006.24

Cited by 165 publications

(156 citation statements)

References 10 publications

Supporting

Mentioning

142

Contrasting

Unclassified

Order By: Relevance

“…However, join point decapsulation in AspectJ is fully unconstrained, without even an option to re-establish encapsulation thus failing our goal to avoid a premature bias towards strictness nor flexibility. This is where approaches like open modules [2] and XPI [8] try to help, by making join points parts of the explicit module interface. We will discuss these approaches as we go through the four principles.…”

Section: Decapsulationmentioning

confidence: 99%

See 1 more Smart Citation

Gradual Encapsulation.

Herrmann¹

2008

JOT

View full text Add to dashboard Cite

Strictly enforced encapsulation is a key concept for modular software designs. However, in many situations like unanticipated reuse, productivity can be raised by a more flexible approach to encapsulation. Also the discussion about the role of "obliviousness" in aspect-oriented programming is one instance of a general conflict between strictness and flexibility. Here, different technologies take different stands and the choice of a particular technology locks a project into prioritizing one side over the other. In this paper we suggest that this choice should not be determined by technology but technology should support the co-existence of encapsulation and its inversedecapsulation -within a single system. We postulate four principles that define a solution space, called "gradual encapsulation", in which each project should find the best fitting balance between encapsulation and decapsulation with the option to shift this balance during the life time of a system. We use the programming language ObjectTeams/Java for illustrating how encapsulation and decapsulation can be supported by technology and how the four principles can be implemented on top of such technology.

show abstract

Section: Decapsulationmentioning

confidence: 99%

“…One might want to compare our join point policy to the pointcut interfaces in the open modules approach [2] or XPI [8]. Firstly, both approaches completely lack any support for controlling API decapsulation.…”

Section: Principlesmentioning

confidence: 99%

Gradual Encapsulation.

Herrmann¹

2008

JOT

View full text Add to dashboard Cite

show abstract

“…Once the interfaces are defined (and respected), aspect and base code become symmetrically oblivious to each others' design decisions. More recently, the interfaces that are defined by the design rules can be implemented as Explicit Pointcut Interfaces (XPI's) using AspectJ [27]. Using XPIs, pointcuts are declared globally and some constraints can be verified on these pointcuts using other pointcuts.…”

Section: Design Rules and Xpimentioning

confidence: 99%

Application-Specific Models and Pointcuts Using a Logic Meta Language

Brichau

Kellens

Gybels

et al. 2007

Advances in Smalltalk

View full text Add to dashboard Cite

In contemporary aspect-oriented languages, pointcuts are usually specified directly in terms of the structure of the source code. The definition of such low-level pointcuts requires aspect developers to have a profound understanding of the entire application's implementation and often leads to complex, fragile, and hard to maintain pointcut definitions. To resolve these issues, we present an aspect-oriented programming system that features a logic-based pointcut language that is open such that it can be extended with application-specific pointcut predicates. These predicates define an application-specific model that serves as a contract that base-program developers provide and aspect developers can depend upon. As a result, pointcuts can be specified in terms of this more high-level model of the application which confines all intricate implementation details that are otherwise exposed in the pointcut definitions themselves.

show abstract

“…Hence, the application of AO language features cannot be ad hoc and must follow deliberate design decisions. A number of studies have examined design and programming patterns and strategies to solve common problems in the development of modules and applications (Bynens et al, 2007;Griswold et al, 2006;Hanenberg and Schmidmeier, 2003a, b;Hanenberg and Unland, 2001;Laddad, 2002;Lagaisse and Joosen, 2006;Miles, 2004;Noble et al, 2007). However, there are few conclusive contributions concerning the use or application of AO patterns for framework development from scratch.…”

Section: Introductionmentioning

confidence: 99%

AJMU: An Aspect-Oriented Framework for Evaluating the Usability of WIMP Applications

Casas¹,

Trejo²,

Farías³

2015

J. of Software Engineering

View full text Add to dashboard Cite

Aspect-Oriented Programming (AOP) is recognized as one of the main techniques for separation of concerns. AOP has been used for automatic evaluation of the usability of WIMP applications, with the aim of monitoring events and GUI components and recording data in logs. A weakness of AOP approaches is low semantic value and a low level of abstraction of the results. One possible solution to overcome these limitations is to use an AO framework for assessing the usability of user tasks. However, little research has been devoted the development of AO frameworks from scratch. Although different design and programming patterns are available, insufficient experience has been reported regarding their application in the development of frameworks. This paper presents AJMU, an AO framework for the automatic evaluation of the usability of user tasks in desktop applications. AJMU was developed from scratch, using AO patterns. This paper also reports on experiments involving AJMU's instantiation with real applications.Key words: Usability, framework, aspect-oriented programming, design patterns, Aspect J INTRODUCTIONAspect-Oriented Programming (AOP; Kiczales et al., 1997) has been used to implement the automatic evaluation of the usability of WIMP applications (Bateman et al., 2009;Holzinger et al., 2011;Humayoun et al., 2009;Shekh and Tyerman, 2010;Tao, 2008Tao, , 2012Tarta and Moldovan, 2006). The predominant approach in this research has been to trace events and the execution of GUI components and store the data in a log, without any context of greater significance. Consequently, the evaluation of usability has little relevance for the evaluator and is not at an appropriate level of abstraction.An AO framework that automatically assesses the different factors of usability (efficiency, effectiveness and satisfaction) for user tasks would be a more appropriate tool. A user task is a unit of analysis that is more relevant and more complex, requiring the implementation of diverse functions, relationships and interactions. Even though popular AO frameworks exist (Spring AOP and JBoss AOP), research on AO frameworks is still in a nascent stage. AOP has primarily been proposed to overcome the weaknesses of OO frameworks (Kulesza et al., 2006;Santos et al., 2007;Vaira and Caplinskas, 2011) and not so much for building frameworks from scratch.When developing a framework rather than an ordinary application, some program constructs or "design elements," are very important. These design elements include abstract modules (classes

show abstract

Modular software design with crosscutting interfaces

Cited by 165 publications

References 10 publications

Gradual Encapsulation.

Gradual Encapsulation.

Application-Specific Models and Pointcuts Using a Logic Meta Language

AJMU: An Aspect-Oriented Framework for Evaluating the Usability of WIMP Applications

Contact Info

Product

Resources

About