際際滷shows by User: khoffman / http://www.slideshare.net/images/logo.gif 際際滷shows by User: khoffman / Thu, 13 Aug 2009 03:40:35 GMT 際際滷Share feed for 際際滷shows by User: khoffman Semantics-Aware Trace Analysis [PLDI 2009] /khoffman/semanticsaware-trace-analysis-pldi-2009 hoffman-semantics-aware-trace-analysis-pldi-2009-090813034044-phpapp01
We present a novel dynamic program analysis that builds a semantic view of program executions. These views reflect program abstractions and aspects; however, views are not simply projections of execution traces, but are linked to each other to capture semantic interactions among abstractions at different levels of granularity in a scalable manner. We describe our approach in the context of Java and demonstrate its utility to improve regression analysis. We first formalize a subset of Java and a grammar for traces generated at program execution. We then introduce several types of views used to analyze regression bugs along with a novel, scalable technique for semantic differencing of traces from different versions of the same program. Benchmark results on large open-source Java programs demonstrate that semantic-aware trace differencing can identify precise and useful details about the underlying cause for a regression, even in programs that use reflection, multithreading, or dynamic code generation, features that typically confound other analysis techniques.]]>
We present a novel dynamic program analysis that builds a semantic view of program executions. These views reflect program abstractions and aspects; however, views are not simply projections of execution traces, but are linked to each other to capture semantic interactions among abstractions at different levels of granularity in a scalable manner. We describe our approach in the context of Java and demonstrate its utility to improve regression analysis. We first formalize a subset of Java and a grammar for traces generated at program execution. We then introduce several types of views used to analyze regression bugs along with a novel, scalable technique for semantic differencing of traces from different versions of the same program. Benchmark results on large open-source Java programs demonstrate that semantic-aware trace differencing can identify precise and useful details about the underlying cause for a regression, even in programs that use reflection, multithreading, or dynamic code generation, features that typically confound other analysis techniques.]]> Thu, 13 Aug 2009 03:40:35 GMT /khoffman/semanticsaware-trace-analysis-pldi-2009 khoffman@slideshare.net(khoffman) Semantics-Aware Trace Analysis [PLDI 2009] khoffman We present a novel dynamic program analysis that builds a semantic view of program executions. These views reflect program abstractions and aspects; however, views are not simply projections of execution traces, but are linked to each other to capture semantic interactions among abstractions at different levels of granularity in a scalable manner. We describe our approach in the context of Java and demonstrate its utility to improve regression analysis. We first formalize a subset of Java and a grammar for traces generated at program execution. We then introduce several types of views used to analyze regression bugs along with a novel, scalable technique for semantic differencing of traces from different versions of the same program. Benchmark results on large open-source Java programs demonstrate that semantic-aware trace differencing can identify precise and useful details about the underlying cause for a regression, even in programs that use reflection, multithreading, or dynamic code generation, features that typically confound other analysis techniques. <img style="border:1px solid #C3E6D8;float:right;" alt="" src="https://cdn.slidesharecdn.com/ss_thumbnails/hoffman-semantics-aware-trace-analysis-pldi-2009-090813034044-phpapp01-thumbnail.jpg?width=120&amp;height=120&amp;fit=bounds" /><br> We present a novel dynamic program analysis that builds a semantic view of program executions. These views reflect program abstractions and aspects; however, views are not simply projections of execution traces, but are linked to each other to capture semantic interactions among abstractions at different levels of granularity in a scalable manner. We describe our approach in the context of Java and demonstrate its utility to improve regression analysis. We first formalize a subset of Java and a grammar for traces generated at program execution. We then introduce several types of views used to analyze regression bugs along with a novel, scalable technique for semantic differencing of traces from different versions of the same program. Benchmark results on large open-source Java programs demonstrate that semantic-aware trace differencing can identify precise and useful details about the underlying cause for a regression, even in programs that use reflection, multithreading, or dynamic code generation, features that typically confound other analysis techniques.
Semantics-Aware Trace Analysis [PLDI 2009] from Kevin Hoffman
]]> 1642 7 https://cdn.slidesharecdn.com/ss_thumbnails/hoffman-semantics-aware-trace-analysis-pldi-2009-090813034044-phpapp01-thumbnail.jpg?width=120&height=120&fit=bounds presentation Black http://activitystrea.ms/schema/1.0/post http://activitystrea.ms/schema/1.0/posted 0 Towards Probabilistic Assessment of Modularity /slideshow/towards-probabilistic-assessment-of-modularity/1853296 hoffman-acom-2008-090813030044-phpapp01
We propose new modularity metrics based on probabilistic computations over weighted design structure matrices, also known as dependency structure matrices. We define how these metrics are calculated, discuss some practical applications, and conclude with future work.]]>
We propose new modularity metrics based on probabilistic computations over weighted design structure matrices, also known as dependency structure matrices. We define how these metrics are calculated, discuss some practical applications, and conclude with future work.]]> Thu, 13 Aug 2009 03:00:44 GMT /slideshow/towards-probabilistic-assessment-of-modularity/1853296 khoffman@slideshare.net(khoffman) Towards Probabilistic Assessment of Modularity khoffman We propose new modularity metrics based on probabilistic computations over weighted design structure matrices, also known as dependency structure matrices. We define how these metrics are calculated, discuss some practical applications, and conclude with future work. <img style="border:1px solid #C3E6D8;float:right;" alt="" src="https://cdn.slidesharecdn.com/ss_thumbnails/hoffman-acom-2008-090813030044-phpapp01-thumbnail.jpg?width=120&amp;height=120&amp;fit=bounds" /><br> We propose new modularity metrics based on probabilistic computations over weighted design structure matrices, also known as dependency structure matrices. We define how these metrics are calculated, discuss some practical applications, and conclude with future work.
Towards Probabilistic Assessment of Modularity from Kevin Hoffman
]]> 390 3 https://cdn.slidesharecdn.com/ss_thumbnails/hoffman-acom-2008-090813030044-phpapp01-thumbnail.jpg?width=120&height=120&fit=bounds presentation Black http://activitystrea.ms/schema/1.0/post http://activitystrea.ms/schema/1.0/posted 0 Towards Reusable Components With Aspects [ICSE 2008] /slideshow/towards-reusable-components-with-aspects-icse-2008/415507 khoffmantowardsreusablecomponentswithaspectsicse08-1211212002397393-8
Does obliviousness increase overall modularity? This presents the results of an empirical study that focuses on the tradeoffs between obliviousness and modularity. The results may surprise you!]]>
Does obliviousness increase overall modularity? This presents the results of an empirical study that focuses on the tradeoffs between obliviousness and modularity. The results may surprise you!]]> Mon, 19 May 2008 08:48:12 GMT /slideshow/towards-reusable-components-with-aspects-icse-2008/415507 khoffman@slideshare.net(khoffman) Towards Reusable Components With Aspects [ICSE 2008] khoffman Does obliviousness increase overall modularity? This presents the results of an empirical study that focuses on the tradeoffs between obliviousness and modularity. The results may surprise you! <img style="border:1px solid #C3E6D8;float:right;" alt="" src="https://cdn.slidesharecdn.com/ss_thumbnails/khoffmantowardsreusablecomponentswithaspectsicse08-1211212002397393-8-thumbnail.jpg?width=120&amp;height=120&amp;fit=bounds" /><br> Does obliviousness increase overall modularity? This presents the results of an empirical study that focuses on the tradeoffs between obliviousness and modularity. The results may surprise you!
Towards Reusable Components With Aspects [ICSE 2008] from Kevin Hoffman
]]> 642 7 https://cdn.slidesharecdn.com/ss_thumbnails/khoffmantowardsreusablecomponentswithaspectsicse08-1211212002397393-8-thumbnail.jpg?width=120&height=120&fit=bounds presentation Black http://activitystrea.ms/schema/1.0/post http://activitystrea.ms/schema/1.0/posted 0 Aspect-based Introspection And Change Analysis For Evolving Programs [RAMSE @ ECOOP07] /slideshow/aspectbased-introspection-and-change-analysis-for-evolving-programs-ramse-ecoop07/385198 khoffmanramse07aspectbasedintrospectionandchangeanalysisforevolvingprograms-1209756783962531-8
We breaks as programs change. We introduce a tracing and analysis framework that leverages aspect-oriented programming and reflection to (a) capture partial or full execution traces with high-level semantics, (b) compare and analyze traces across program versions to aid in understanding the affects of code changes on program execution.]]>
We breaks as programs change. We introduce a tracing and analysis framework that leverages aspect-oriented programming and reflection to (a) capture partial or full execution traces with high-level semantics, (b) compare and analyze traces across program versions to aid in understanding the affects of code changes on program execution.]]> Fri, 02 May 2008 12:38:20 GMT /slideshow/aspectbased-introspection-and-change-analysis-for-evolving-programs-ramse-ecoop07/385198 khoffman@slideshare.net(khoffman) Aspect-based Introspection And Change Analysis For Evolving Programs [RAMSE @ ECOOP07] khoffman We breaks as programs change. We introduce a tracing and analysis framework that leverages aspect-oriented programming and reflection to (a) capture partial or full execution traces with high-level semantics, (b) compare and analyze traces across program versions to aid in understanding the affects of code changes on program execution. <img style="border:1px solid #C3E6D8;float:right;" alt="" src="https://cdn.slidesharecdn.com/ss_thumbnails/khoffmanramse07aspectbasedintrospectionandchangeanalysisforevolvingprograms-1209756783962531-8-thumbnail.jpg?width=120&amp;height=120&amp;fit=bounds" /><br> We breaks as programs change. We introduce a tracing and analysis framework that leverages aspect-oriented programming and reflection to (a) capture partial or full execution traces with high-level semantics, (b) compare and analyze traces across program versions to aid in understanding the affects of code changes on program execution.
Aspect-based Introspection And Change Analysis For Evolving Programs [RAMSE @ ECOOP07] from Kevin Hoffman
]]> 367 2 https://cdn.slidesharecdn.com/ss_thumbnails/khoffmanramse07aspectbasedintrospectionandchangeanalysisforevolvingprograms-1209756783962531-8-thumbnail.jpg?width=120&height=120&fit=bounds presentation Black http://activitystrea.ms/schema/1.0/post http://activitystrea.ms/schema/1.0/posted 0 Aspect-oriented Transactions via Explicit Join Points /slideshow/aspectoriented-transactions-via-explicit-join-points/385186 khoffmanaspectorientedtransactionsviaexplicitjoinpoints-1209756499095954-9
We demonstrate how to safely and effectively implement transactions following an aspect-oriented paradigm using our proposed extension of AspectJ, Explicit Join Points.]]>
We demonstrate how to safely and effectively implement transactions following an aspect-oriented paradigm using our proposed extension of AspectJ, Explicit Join Points.]]> Fri, 02 May 2008 12:28:56 GMT /slideshow/aspectoriented-transactions-via-explicit-join-points/385186 khoffman@slideshare.net(khoffman) Aspect-oriented Transactions via Explicit Join Points khoffman We demonstrate how to safely and effectively implement transactions following an aspect-oriented paradigm using our proposed extension of AspectJ, Explicit Join Points. <img style="border:1px solid #C3E6D8;float:right;" alt="" src="https://cdn.slidesharecdn.com/ss_thumbnails/khoffmanaspectorientedtransactionsviaexplicitjoinpoints-1209756499095954-9-thumbnail.jpg?width=120&amp;height=120&amp;fit=bounds" /><br> We demonstrate how to safely and effectively implement transactions following an aspect-oriented paradigm using our proposed extension of AspectJ, Explicit Join Points.
Aspect-oriented Transactions via Explicit Join Points from Kevin Hoffman
]]> 290 2 https://cdn.slidesharecdn.com/ss_thumbnails/khoffmanaspectorientedtransactionsviaexplicitjoinpoints-1209756499095954-9-thumbnail.jpg?width=120&height=120&fit=bounds presentation Black http://activitystrea.ms/schema/1.0/post http://activitystrea.ms/schema/1.0/posted 0 Aspects Made Explicit for Safe Transactional Semantics [DSN 2006] /slideshow/aspects-made-explicit-for-safe-transactional-semantics-dsn-2006/385178 khoffmandsn2006aspectsmadeexplicitforsafetransactionalsemantics-1209755681064982-9
Implementing the transactions cross-cutting concern in AspectJ faces many challenges. We propose making join points an explicit part of the base code to overcome these challenges.]]>
Implementing the transactions cross-cutting concern in AspectJ faces many challenges. We propose making join points an explicit part of the base code to overcome these challenges.]]> Fri, 02 May 2008 12:15:36 GMT /slideshow/aspects-made-explicit-for-safe-transactional-semantics-dsn-2006/385178 khoffman@slideshare.net(khoffman) Aspects Made Explicit for Safe Transactional Semantics [DSN 2006] khoffman Implementing the transactions cross-cutting concern in AspectJ faces many challenges. We propose making join points an explicit part of the base code to overcome these challenges. <img style="border:1px solid #C3E6D8;float:right;" alt="" src="https://cdn.slidesharecdn.com/ss_thumbnails/khoffmandsn2006aspectsmadeexplicitforsafetransactionalsemantics-1209755681064982-9-thumbnail.jpg?width=120&amp;height=120&amp;fit=bounds" /><br> Implementing the transactions cross-cutting concern in AspectJ faces many challenges. We propose making join points an explicit part of the base code to overcome these challenges.
Aspects Made Explicit for Safe Transactional Semantics [DSN 2006] from Kevin Hoffman
]]> 356 2 https://cdn.slidesharecdn.com/ss_thumbnails/khoffmandsn2006aspectsmadeexplicitforsafetransactionalsemantics-1209755681064982-9-thumbnail.jpg?width=120&height=120&fit=bounds presentation Black http://activitystrea.ms/schema/1.0/post http://activitystrea.ms/schema/1.0/posted 0 Introduction to AOP, AspectJ, and Explicit Join Points /khoffman/introduction-to-aop-aspectj-and-explicit-join-points khoffmanslidesintroductiontoaopaspectjejps-1209748037934616-8
An introduction to and history of aspect-oriented programming. A short overview of AspectJ, certain challenges such as the state-point separation problem, and how explicit join points (EJPs) help mitigate these problems.]]>
An introduction to and history of aspect-oriented programming. A short overview of AspectJ, certain challenges such as the state-point separation problem, and how explicit join points (EJPs) help mitigate these problems.]]> Fri, 02 May 2008 10:09:13 GMT /khoffman/introduction-to-aop-aspectj-and-explicit-join-points khoffman@slideshare.net(khoffman) Introduction to AOP, AspectJ, and Explicit Join Points khoffman An introduction to and history of aspect-oriented programming. A short overview of AspectJ, certain challenges such as the state-point separation problem, and how explicit join points (EJPs) help mitigate these problems. <img style="border:1px solid #C3E6D8;float:right;" alt="" src="https://cdn.slidesharecdn.com/ss_thumbnails/khoffmanslidesintroductiontoaopaspectjejps-1209748037934616-8-thumbnail.jpg?width=120&amp;height=120&amp;fit=bounds" /><br> An introduction to and history of aspect-oriented programming. A short overview of AspectJ, certain challenges such as the state-point separation problem, and how explicit join points (EJPs) help mitigate these problems.
Introduction to AOP, AspectJ, and Explicit Join Points from Kevin Hoffman
]]> 1371 7 https://cdn.slidesharecdn.com/ss_thumbnails/khoffmanslidesintroductiontoaopaspectjejps-1209748037934616-8-thumbnail.jpg?width=120&height=120&fit=bounds presentation Black http://activitystrea.ms/schema/1.0/post http://activitystrea.ms/schema/1.0/posted 0 Bridging Java And AspectJ [PPPJ08] /slideshow/bridging-java-and-aspect-j-pppj08/385003 khoffmanpppj08bridgingjavaandaspectj-1209747434986925-8
Through AspectJ, aspect-oriented programming (AOP) is becoming of increasing interest and availability to Java programmers as it matures as a methodology for improved software modularity via the separation of cross-cutting concerns. AOP proponents often advocate a development strategy where Java programmers write the main application, ignoring cross-cutting concerns, and then AspectJ programmers, domain experts in their specific concerns, weave in the logic for these more specialized cross-cutting concerns. However, several authors have recently debated the merits of this strategy by empirically showing certain drawbacks. The proposed solutions paint a different development strategy where base code and aspect programmers are aware of each other (to varying degrees) and interactions between cross-cutting concerns are planned for early on. Herein we explore new possibilities in the language design space that open up when the base code is aware of crosscutting aspects. Using our insights from this exploration we concretize these new possibilities by extending AspectJ with concise yet powerful constructs, while maintaining full backwards compatibility. These new constructs allow base code and aspects to cooperate in ways that were previously not possible: arbitrary blocks of code can be advised, advice can be explicitly parameterized, base code can guide aspects in where to apply advice, and aspects can statically enforce new constraints upon the base code that they advise. These new techniques allow aspect modularity and program safety to increase. We illustrate the value of our extensions through an example based on transactions.]]>
Through AspectJ, aspect-oriented programming (AOP) is becoming of increasing interest and availability to Java programmers as it matures as a methodology for improved software modularity via the separation of cross-cutting concerns. AOP proponents often advocate a development strategy where Java programmers write the main application, ignoring cross-cutting concerns, and then AspectJ programmers, domain experts in their specific concerns, weave in the logic for these more specialized cross-cutting concerns. However, several authors have recently debated the merits of this strategy by empirically showing certain drawbacks. The proposed solutions paint a different development strategy where base code and aspect programmers are aware of each other (to varying degrees) and interactions between cross-cutting concerns are planned for early on. Herein we explore new possibilities in the language design space that open up when the base code is aware of crosscutting aspects. Using our insights from this exploration we concretize these new possibilities by extending AspectJ with concise yet powerful constructs, while maintaining full backwards compatibility. These new constructs allow base code and aspects to cooperate in ways that were previously not possible: arbitrary blocks of code can be advised, advice can be explicitly parameterized, base code can guide aspects in where to apply advice, and aspects can statically enforce new constraints upon the base code that they advise. These new techniques allow aspect modularity and program safety to increase. We illustrate the value of our extensions through an example based on transactions.]]> Fri, 02 May 2008 10:01:10 GMT /slideshow/bridging-java-and-aspect-j-pppj08/385003 khoffman@slideshare.net(khoffman) Bridging Java And AspectJ [PPPJ08] khoffman Through AspectJ, aspect-oriented programming (AOP) is becoming of increasing interest and availability to Java programmers as it matures as a methodology for improved software modularity via the separation of cross-cutting concerns. AOP proponents often advocate a development strategy where Java programmers write the main application, ignoring cross-cutting concerns, and then AspectJ programmers, domain experts in their specific concerns, weave in the logic for these more specialized cross-cutting concerns. However, several authors have recently debated the merits of this strategy by empirically showing certain drawbacks. The proposed solutions paint a different development strategy where base code and aspect programmers are aware of each other (to varying degrees) and interactions between cross-cutting concerns are planned for early on. Herein we explore new possibilities in the language design space that open up when the base code is aware of crosscutting aspects. Using our insights from this exploration we concretize these new possibilities by extending AspectJ with concise yet powerful constructs, while maintaining full backwards compatibility. These new constructs allow base code and aspects to cooperate in ways that were previously not possible: arbitrary blocks of code can be advised, advice can be explicitly parameterized, base code can guide aspects in where to apply advice, and aspects can statically enforce new constraints upon the base code that they advise. These new techniques allow aspect modularity and program safety to increase. We illustrate the value of our extensions through an example based on transactions. <img style="border:1px solid #C3E6D8;float:right;" alt="" src="https://cdn.slidesharecdn.com/ss_thumbnails/khoffmanpppj08bridgingjavaandaspectj-1209747434986925-8-thumbnail.jpg?width=120&amp;height=120&amp;fit=bounds" /><br> Through AspectJ, aspect-oriented programming (AOP) is becoming of increasing interest and availability to Java programmers as it matures as a methodology for improved software modularity via the separation of cross-cutting concerns. AOP proponents often advocate a development strategy where Java programmers write the main application, ignoring cross-cutting concerns, and then AspectJ programmers, domain experts in their specific concerns, weave in the logic for these more specialized cross-cutting concerns. However, several authors have recently debated the merits of this strategy by empirically showing certain drawbacks. The proposed solutions paint a different development strategy where base code and aspect programmers are aware of each other (to varying degrees) and interactions between cross-cutting concerns are planned for early on. Herein we explore new possibilities in the language design space that open up when the base code is aware of crosscutting aspects. Using our insights from this exploration we concretize these new possibilities by extending AspectJ with concise yet powerful constructs, while maintaining full backwards compatibility. These new constructs allow base code and aspects to cooperate in ways that were previously not possible: arbitrary blocks of code can be advised, advice can be explicitly parameterized, base code can guide aspects in where to apply advice, and aspects can statically enforce new constraints upon the base code that they advise. These new techniques allow aspect modularity and program safety to increase. We illustrate the value of our extensions through an example based on transactions.
Bridging Java And AspectJ [PPPJ08] from Kevin Hoffman
]]> 661 3 https://cdn.slidesharecdn.com/ss_thumbnails/khoffmanpppj08bridgingjavaandaspectj-1209747434986925-8-thumbnail.jpg?width=120&height=120&fit=bounds presentation Black http://activitystrea.ms/schema/1.0/post http://activitystrea.ms/schema/1.0/posted 0 https://public.slidesharecdn.com/v2/images/profile-picture.png www.kevinjhoffman.com/ https://cdn.slidesharecdn.com/ss_thumbnails/hoffman-semantics-aware-trace-analysis-pldi-2009-090813034044-phpapp01-thumbnail.jpg?width=320&height=320&fit=bounds khoffman/semanticsaware-trace-analysis-pldi-2009 Semantics-Aware Trace ... https://cdn.slidesharecdn.com/ss_thumbnails/hoffman-acom-2008-090813030044-phpapp01-thumbnail.jpg?width=320&height=320&fit=bounds slideshow/towards-probabilistic-assessment-of-modularity/1853296 Towards Probabilistic ... https://cdn.slidesharecdn.com/ss_thumbnails/khoffmantowardsreusablecomponentswithaspectsicse08-1211212002397393-8-thumbnail.jpg?width=320&height=320&fit=bounds slideshow/towards-reusable-components-with-aspects-icse-2008/415507 Towards Reusable Compo...