Compilers: principles, techniques, and tools
Compilers: principles, techniques, and tools
An Interpreter for Extended Lambda Calculus
An Interpreter for Extended Lambda Calculus
Dynamically scoped functions as the essence of AOP
ACM SIGPLAN Notices
AspectJ in Action: Practical Aspect-Oriented Programming
AspectJ in Action: Practical Aspect-Oriented Programming
Java(TM) Language Specification, The (3rd Edition) (Java (Addison-Wesley))
Java(TM) Language Specification, The (3rd Edition) (Java (Addison-Wesley))
abc: an extensible AspectJ compiler
Proceedings of the 4th international conference on Aspect-oriented software development
A join point for loops in AspectJ
Proceedings of the 5th international conference on Aspect-oriented software development
AO challenge - implementing the ACID properties for transactional objects
Proceedings of the 5th international conference on Aspect-oriented software development
Proceedings of the 6th international conference on Aspect-oriented software development
Bridging Java and AspectJ through explicit join points
Proceedings of the 5th international symposium on Principles and practice of programming in Java
StrongAspectJ: flexible and safe pointcut/advice bindings
Proceedings of the 7th international conference on Aspect-oriented software development
A synchronized block join point for AspectJ
Proceedings of the 7th workshop on Foundations of aspect-oriented languages
Scala Actors: Unifying thread-based and event-based programming
Theoretical Computer Science
Expressive scoping of distributed aspects
Proceedings of the 8th ACM international conference on Aspect-oriented software development
Proceedings of the 8th workshop on Aspects, components, and patterns for infrastructure software
Aspect-oriented support for synchronization in parallel computing
Proceedings of the 1st workshop on Linking aspect technology and evolution
Programming in Scala: A Comprehensive Step-by-step Guide
Programming in Scala: A Comprehensive Step-by-step Guide
How should context-escaping closures proceed?
International Workshop on Context-Oriented Programming
JavaΩ: The Structures and the Implementation of a Preprocessor for Java with m and mc parameters
Fundamenta Informaticae - Concurrency Specification and Programming (CS&P)
Stepping Stones over the Refactoring Rubicon
Genoa Proceedings of the 23rd European Conference on ECOOP 2009 --- Object-Oriented Programming
Extending AspectJ for separating regions
GPCE '09 Proceedings of the eighth international conference on Generative programming and component engineering
Types and modularity for implicit invocation with implicit announcement
ACM Transactions on Software Engineering and Methodology (TOSEM)
A fine-grained join point model for more reusable aspects
APLAS'06 Proceedings of the 4th Asian conference on Programming Languages and Systems
Join point interfaces for modular reasoning in aspect-oriented programs
Proceedings of the 19th ACM SIGSOFT symposium and the 13th European conference on Foundations of software engineering
ACM Transactions on Programming Languages and Systems (TOPLAS)
Hierarchical concern-based pointcuts
Proceedings of the 8th international workshop on Advanced modularization techniques
A brief tour of join point interfaces
Proceedings of the 12th annual international conference companion on Aspect-oriented software development
Fine-grained annotations for pointcuts with a finer granularity
Proceedings of the 28th Annual ACM Symposium on Applied Computing
Join point interfaces for safe and flexible decoupling of aspects
ACM Transactions on Software Engineering and Methodology (TOSEM)
Hi-index | 0.00 |
Block joinpoints allow programmers to explicitly mark regions of base code as "to be advised", thus avoiding the need to extract the block into a method just for the sake of creating a joinpoint. Block joinpoints appear simple to define and implement. After all, regular block statements in Java-like languages are constructs well-known to the programmer and have simple control-flow and data-flow semantics. Our major insight is, however, that by exposing a block of code as a joinpoint, the code is no longer only called in its declaring static context but also from within aspect code. The block effectively becomes a closure, i.e., an anonymous function that may capture values from the enclosing lexical scope. We discuss research on closures that reveals several important design questions that any semantic definition of closures or block joinpoints must answer. In this paper we show that all existing proposals for block joinpoints answer these questions insufficiently, and hence exhibit a semantics either undefined or likely surprising to Java programmers. As a solution, we propose a syntax, semantics, and implementation of Closure Joinpoints, block joinpoints based on closures. As we show, our design decisions yield a semantics that follows the principle of least surprise.