One possible approach of AOP is to weave advice into existing classes. This approach is taken by AspectJ. In this presentation we explore how this is done, and look at some alternatives as well.
Aspect-oriented programming (AOP) aims to increase modularity by allowing separation of cross-cutting concerns. It was developed by Gregor Kiczales at Xerox PARC and allows defining aspects that can add additional behaviors to join points in a program. In AOP, aspects are implemented through advice associated with pointcuts that match join points. The weaving process links aspects with application objects to create advised objects. In Spring AOP, this is done through dynamic proxies at runtime.
Introduction to AOP, AspectJ, and Explicit Join PointsKevin Hoffman
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.
Aspect-oriented programming (AOP) is a programming paradigm that aims to modularize cross-cutting concerns in code. AOP was developed by Gregor Kiczales and colleagues at Xerox PARC. AspectJ is a popular implementation of AOP for Java that uses pointcuts, advice, and inter-type declarations to inject additional behavior into existing code by means of weaving. Pointcuts define where advice should be applied, advice is the additional code to execute, and weaving is the process of applying aspects to code.
This document introduces aspect-oriented programming (AOP) and compares AOP frameworks. It discusses how AOP aims to increase modularity by separating cross-cutting concerns. It then defines key AOP terms like join points, advice, and pointcuts. The document compares static and dynamic AOP weaving approaches and evaluates various frameworks based on their expressiveness and runtime behavior.
Introduction to Aspect Oriented Programming (DDD South West 4.0)Yan Cui
Introduction to AOP talk at DDD SouthWest 4.0, including examples of AOP using dynamic proxies, functional programming, dynamic language and PostSharp.
The document introduces aspect oriented programming (AOP) as a programming paradigm that deals with cross-cutting concerns, such as logging and transaction management, that cut across multiple parts of a system. It discusses how AOP increases modularity and manages these cross-cutting concerns through features like advice, pointcuts, and weaving. Benefits of AOP include cleaner code, reduced repetition, and better encapsulation. Common AOP techniques are interceptors using dependency injection containers and IL code weaving tools.
Aspect-oriented programming (AOP) aims to increase modularity by allowing separation of cross-cutting concerns. It was developed by Gregor Kiczales at Xerox PARC and allows defining aspects that can add additional behaviors to join points in a program. In AOP, aspects are implemented through advice associated with pointcuts that match join points. The weaving process links aspects with application objects to create advised objects. In Spring AOP, this is done through dynamic proxies at runtime.
Introduction to AOP, AspectJ, and Explicit Join PointsKevin Hoffman
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.
Aspect-oriented programming (AOP) is a programming paradigm that aims to modularize cross-cutting concerns in code. AOP was developed by Gregor Kiczales and colleagues at Xerox PARC. AspectJ is a popular implementation of AOP for Java that uses pointcuts, advice, and inter-type declarations to inject additional behavior into existing code by means of weaving. Pointcuts define where advice should be applied, advice is the additional code to execute, and weaving is the process of applying aspects to code.
This document introduces aspect-oriented programming (AOP) and compares AOP frameworks. It discusses how AOP aims to increase modularity by separating cross-cutting concerns. It then defines key AOP terms like join points, advice, and pointcuts. The document compares static and dynamic AOP weaving approaches and evaluates various frameworks based on their expressiveness and runtime behavior.
Introduction to Aspect Oriented Programming (DDD South West 4.0)Yan Cui
Introduction to AOP talk at DDD SouthWest 4.0, including examples of AOP using dynamic proxies, functional programming, dynamic language and PostSharp.
The document introduces aspect oriented programming (AOP) as a programming paradigm that deals with cross-cutting concerns, such as logging and transaction management, that cut across multiple parts of a system. It discusses how AOP increases modularity and manages these cross-cutting concerns through features like advice, pointcuts, and weaving. Benefits of AOP include cleaner code, reduced repetition, and better encapsulation. Common AOP techniques are interceptors using dependency injection containers and IL code weaving tools.
OSGi DevCon 2013
There are a number component models available to OSGi developers; Declarative Services (DS), Blueprint (BP), Enterprise JavaBeans (EJB), Contexts and Dependency Injection (CDI). Some have their roots in Java EE, some in open source projects such as the Spring Framework, others are standards at the OSGi Alliance, and some have DNA from all three. As is often the case where there are options available, there's rarely a one-size-fits-all. The 'right' choice may depend on the type of project you're working on, the existing assets, tools and skills at your disposal, and the runtime you're looking to deploy to. This talk will provide a brief overview of the four component models listed, describe their scope of capabilities, standards coverage, tools support, and available implementations in an efforts to help OSGi users find a path to a component model best suited to their particular task.
This document discusses various techniques for designing usable APIs, including:
- Adopting a user-centered perspective when designing APIs and considering concepts like naming, explicit context, error reporting, and incremental design.
- Techniques like using language constructs to make intent clear, giving control to the caller, and test-driven development.
- The document also discusses some surprising findings from user studies that showed factories can reduce usability and that optional constructor parameters are preferred. Links to additional resources on API usability are provided.
Common ASP.NET Design Patterns - Telerik India DevCon 2013Steven Smith
This document provides an overview of common ASP.NET design patterns, including Singleton, Strategy, Repository, Proxy, Command, and Factory patterns. It discusses the intent, structure, and usage of each pattern. Code examples and references are also provided. Real-world examples are discussed to demonstrate how design patterns can be used to address issues like tight coupling and improve code quality during refactoring or initial design.
Design Pattern Mastery - Momentum Dev Con 19 Apr 2018Steven Smith
Design patterns help developers and teams solve problems using proven approaches. In this talk, you'll learn how to solve a series of real world problems by applying patterns. Not only do patterns help individual developers solve particular problems, but they also enable teams to discuss design decisions using a richer, more descriptive language. By the end, you'll have some concrete tools you can apply, and hopefully the desire to master more patterns as you continue to improve!
SiriusCon 2015 - Breathe Life into Your Designer!melbats
You have your shiny new DSL up and running thanks to the Eclipse Modeling Technologies and you built a powerful tooling with graphical modelers, textual syntaxes or dedicated editors to support it. But how can you see what is going on when a model is executed ? Don't you need to simulate your design in some way ? Wouldn't you want to see your editors being animated directly within your modeling environment based on execution traces or simulator results?
The GEMOC Research Project designed a methodology to bring animation and execution analysis to DSLs. The companion technologies required to put this in action are small dedicated components (all open-source) at a "proof of concept" maturity level extending proven components : Sirius, Eclipse Debug, Xtend making such features within the reach of Eclipse based tooling. The general intent regarding those OSS technologies is to leverage them within different contexts and contribute them to Eclipse once proven strong enough. The method covers a large spectrum of use cases from DSLs with a straightforward execution semantic to a combination of different DSLs with concurrent execution semantic. Any tool provider can leverage both the technologies and the method to provide an executable DSL and animated graphical modelers to its users enabling simulation and debugging at an early phase of the design.
This talk presents the approach, the technologies and demonstrate it through an example: providing Eclipse Debug integration and diagram animation capabilities for Arduino Designer (EPL) : setting breakpoints, stepping forward or backward in the execution, inspecting the variables states... We will walk you through the steps required to develop such features, the choices to make and the trade-offs involved. Expects live demos with simulated blinking leds and a virtual cat robot ! This talks presents also xCapella an industrial use case onwhich the Gemoc methodology was applied.
This talks was presented at SiriusCon 2015 in collaboration with Jérôme Le Noir from Thales.
The Arduino Designer documentation is available on : https://github.com/mbats/arduino/wiki/Documentation
Improving The Quality of Existing SoftwareSteven Smith
Presented at DevReach 2013.
As developers, most of our time is spent working on existing software. Sure, occasionally we get the chance to fire up a new Solution in Visual Studio, and that can be exciting. But after the first day, we find ourselves once more having to deal with the work we did yesterday. And today, we know more than we did yesterday, so there are things we’d do differently, if we had it to do over.
Over time, software rots. If we’re not diligent, our beautiful code can degrade into a worthless mess. Keeping our code in working condition is no different than changing the oil in our car – it’s preventive maintenance. In this session, Steve will look at some common places to look for signs of degradation in existing applications, and steps to take to improve the code. Examples will use C# and primarily ASP.NET.
Design patterns provide common templates for solving similar problems. They also provide a higher-level language for software developers to use to describe approaches they might choose when designing part of an application. This session introduces and applies several patterns useful to web application developers. Examples will primarily use C#/.NET.
EclipseCon France 2016 - Sirius 4.0: Let me Sirius that for you!melbats
- Sirius 4.0 was presented at EclipseCon France in June 2016, with new features including improved internationalization, SVG rendering, and integration with EMF Edit.
- Statistics on Sirius development were provided, with 10 active committers, 84 fixed bugs, and over 900 commits in the last year.
- The talk demonstrated how to define customizable properties views for complex Ecore models in Sirius using dynamic mappings based on property types. This allows automatically generating appropriate widgets without defining each one individually.
The document discusses the concept of owning or enclosing a language. It argues that if someone could own the English language, it would severely limit free speech and communication. The architecture used to implement currencies inherently leads to enclosure, concentrating power and wealth. Overall, the document cautions against allowing ownership of languages or architectures like currencies that can enable enclosure.
This document provides an overview of key performance indicators (KPIs) and how to define them in Necto Training. It discusses how KPIs can help monitor progress towards goals and highlight variances from targets. It then demonstrates how to use the KPI wizard to define KPIs, including selecting a view, goal, minimum/maximum values, display options, and trend. Users are instructed to define KPIs to track whether sales goals and customer targets have been reached.
The document contains a collection of notes, assignments, and reflections from a student over the course of a school term. It includes the student's spelling test scores improving each term, goals of improving their writing skills and moving up to a higher rugby club level. There are notes from classes on health and PE, science and technology, te reo Māori, geometry, and processing information for speeches. The student reflects on participating in athletic events and their progress in meeting learning intentions and success criteria across various subjects.
1) A survey was conducted of 826 Macau teenagers (380 males, 446 females) to understand their sexual knowledge and experiences.
2) The results showed that 9.87% of males and 4.48% of females reported having sexual experiences. Most partners were high school or university students of similar ages.
3) For first sexual experiences, 20% of males reported being 16 years old, while 20% of females reported being 17 years old.
Аналитические решения в телекомах. Презентация с киевского мероприятия 27.09.12Alexey Kononenko
Управление рисками – Collection
Customer Link Analytics
Тарифное моделирование
Гарантирование доходов - Revenue Assurance
Анализ эксплуатации сети
Анализ эффективности работы IT
The document discusses the concept of owning or enclosing a language. It argues that if someone could own the English language, it would severely limit free speech and communication. The architecture used to implement currencies inherently leads to enclosure, concentrating power and wealth. Overall, the document cautions against allowing ownership of languages or architectures like currencies that can enable enclosure.
OSGi DevCon 2013
There are a number component models available to OSGi developers; Declarative Services (DS), Blueprint (BP), Enterprise JavaBeans (EJB), Contexts and Dependency Injection (CDI). Some have their roots in Java EE, some in open source projects such as the Spring Framework, others are standards at the OSGi Alliance, and some have DNA from all three. As is often the case where there are options available, there's rarely a one-size-fits-all. The 'right' choice may depend on the type of project you're working on, the existing assets, tools and skills at your disposal, and the runtime you're looking to deploy to. This talk will provide a brief overview of the four component models listed, describe their scope of capabilities, standards coverage, tools support, and available implementations in an efforts to help OSGi users find a path to a component model best suited to their particular task.
This document discusses various techniques for designing usable APIs, including:
- Adopting a user-centered perspective when designing APIs and considering concepts like naming, explicit context, error reporting, and incremental design.
- Techniques like using language constructs to make intent clear, giving control to the caller, and test-driven development.
- The document also discusses some surprising findings from user studies that showed factories can reduce usability and that optional constructor parameters are preferred. Links to additional resources on API usability are provided.
Common ASP.NET Design Patterns - Telerik India DevCon 2013Steven Smith
This document provides an overview of common ASP.NET design patterns, including Singleton, Strategy, Repository, Proxy, Command, and Factory patterns. It discusses the intent, structure, and usage of each pattern. Code examples and references are also provided. Real-world examples are discussed to demonstrate how design patterns can be used to address issues like tight coupling and improve code quality during refactoring or initial design.
Design Pattern Mastery - Momentum Dev Con 19 Apr 2018Steven Smith
Design patterns help developers and teams solve problems using proven approaches. In this talk, you'll learn how to solve a series of real world problems by applying patterns. Not only do patterns help individual developers solve particular problems, but they also enable teams to discuss design decisions using a richer, more descriptive language. By the end, you'll have some concrete tools you can apply, and hopefully the desire to master more patterns as you continue to improve!
SiriusCon 2015 - Breathe Life into Your Designer!melbats
You have your shiny new DSL up and running thanks to the Eclipse Modeling Technologies and you built a powerful tooling with graphical modelers, textual syntaxes or dedicated editors to support it. But how can you see what is going on when a model is executed ? Don't you need to simulate your design in some way ? Wouldn't you want to see your editors being animated directly within your modeling environment based on execution traces or simulator results?
The GEMOC Research Project designed a methodology to bring animation and execution analysis to DSLs. The companion technologies required to put this in action are small dedicated components (all open-source) at a "proof of concept" maturity level extending proven components : Sirius, Eclipse Debug, Xtend making such features within the reach of Eclipse based tooling. The general intent regarding those OSS technologies is to leverage them within different contexts and contribute them to Eclipse once proven strong enough. The method covers a large spectrum of use cases from DSLs with a straightforward execution semantic to a combination of different DSLs with concurrent execution semantic. Any tool provider can leverage both the technologies and the method to provide an executable DSL and animated graphical modelers to its users enabling simulation and debugging at an early phase of the design.
This talk presents the approach, the technologies and demonstrate it through an example: providing Eclipse Debug integration and diagram animation capabilities for Arduino Designer (EPL) : setting breakpoints, stepping forward or backward in the execution, inspecting the variables states... We will walk you through the steps required to develop such features, the choices to make and the trade-offs involved. Expects live demos with simulated blinking leds and a virtual cat robot ! This talks presents also xCapella an industrial use case onwhich the Gemoc methodology was applied.
This talks was presented at SiriusCon 2015 in collaboration with Jérôme Le Noir from Thales.
The Arduino Designer documentation is available on : https://github.com/mbats/arduino/wiki/Documentation
Improving The Quality of Existing SoftwareSteven Smith
Presented at DevReach 2013.
As developers, most of our time is spent working on existing software. Sure, occasionally we get the chance to fire up a new Solution in Visual Studio, and that can be exciting. But after the first day, we find ourselves once more having to deal with the work we did yesterday. And today, we know more than we did yesterday, so there are things we’d do differently, if we had it to do over.
Over time, software rots. If we’re not diligent, our beautiful code can degrade into a worthless mess. Keeping our code in working condition is no different than changing the oil in our car – it’s preventive maintenance. In this session, Steve will look at some common places to look for signs of degradation in existing applications, and steps to take to improve the code. Examples will use C# and primarily ASP.NET.
Design patterns provide common templates for solving similar problems. They also provide a higher-level language for software developers to use to describe approaches they might choose when designing part of an application. This session introduces and applies several patterns useful to web application developers. Examples will primarily use C#/.NET.
EclipseCon France 2016 - Sirius 4.0: Let me Sirius that for you!melbats
- Sirius 4.0 was presented at EclipseCon France in June 2016, with new features including improved internationalization, SVG rendering, and integration with EMF Edit.
- Statistics on Sirius development were provided, with 10 active committers, 84 fixed bugs, and over 900 commits in the last year.
- The talk demonstrated how to define customizable properties views for complex Ecore models in Sirius using dynamic mappings based on property types. This allows automatically generating appropriate widgets without defining each one individually.
The document discusses the concept of owning or enclosing a language. It argues that if someone could own the English language, it would severely limit free speech and communication. The architecture used to implement currencies inherently leads to enclosure, concentrating power and wealth. Overall, the document cautions against allowing ownership of languages or architectures like currencies that can enable enclosure.
This document provides an overview of key performance indicators (KPIs) and how to define them in Necto Training. It discusses how KPIs can help monitor progress towards goals and highlight variances from targets. It then demonstrates how to use the KPI wizard to define KPIs, including selecting a view, goal, minimum/maximum values, display options, and trend. Users are instructed to define KPIs to track whether sales goals and customer targets have been reached.
The document contains a collection of notes, assignments, and reflections from a student over the course of a school term. It includes the student's spelling test scores improving each term, goals of improving their writing skills and moving up to a higher rugby club level. There are notes from classes on health and PE, science and technology, te reo Māori, geometry, and processing information for speeches. The student reflects on participating in athletic events and their progress in meeting learning intentions and success criteria across various subjects.
1) A survey was conducted of 826 Macau teenagers (380 males, 446 females) to understand their sexual knowledge and experiences.
2) The results showed that 9.87% of males and 4.48% of females reported having sexual experiences. Most partners were high school or university students of similar ages.
3) For first sexual experiences, 20% of males reported being 16 years old, while 20% of females reported being 17 years old.
Аналитические решения в телекомах. Презентация с киевского мероприятия 27.09.12Alexey Kononenko
Управление рисками – Collection
Customer Link Analytics
Тарифное моделирование
Гарантирование доходов - Revenue Assurance
Анализ эксплуатации сети
Анализ эффективности работы IT
The document discusses the concept of owning or enclosing a language. It argues that if someone could own the English language, it would severely limit free speech and communication. The architecture used to implement currencies inherently leads to enclosure, concentrating power and wealth. Overall, the document cautions against allowing ownership of languages or architectures like currencies that can enable enclosure.
Slides from my presentation at CodeIgniter Conference 2010 in Bristol in August 2010.
What I talked about:
- Startups: methodologies & techniques
- CodeIgniter: applying what we’ve learned
- The future: how could things be better
The document discusses the implementation of Fair Student Funding in Baltimore City Public Schools. It aimed to create a more equitable and transparent funding model that allocated resources based on student needs rather than staffing. Key aspects included devolving dollars previously controlled by the central office to individual schools, establishing weights in the funding formula for student characteristics like performance levels, and implementing caps on gains or losses schools could face in a given year during the transition. The process involved numerous stakeholders and aimed to empower school leaders while holding them accountable for student outcomes.
The document refers to Group 752, but provides no other context or details about this group. It contains a single line of text stating "Group 752" without any further information about the purpose, members, or activities of this group. The brief document does not include enough information to generate a multi-sentence summary.
MinuteProject is a code generation tool that can reverse engineer databases and WSDLs. It was presented along with several demos including generating JPA2 and REST backends from a database, customizing generated code, and using statement driven development to generate REST endpoints from SQL queries. The talk also covered extending MinuteProject by adding new tracks, templates, libraries, and plugins.
Presented by: N.V.Rajasekhar Reddy
www.technolamp.co.in
Want more interesting...
Watch and Like us @ https://www.facebook.com/Technolamp.co.in
subscribe videos @ http://www.youtube.com/user/nvrajasekhar
МАКСИМ БАРВІНСЬКИЙ «AspectJ in Test Automation.» Lviv QA Day 2019QADay
Aspect-oriented programming (AOP) aims to increase modularity by separating cross-cutting concerns. AspectJ is an extension to Java that implements AOP. It allows defining aspects that specify join points (e.g. method calls) in the application execution flow and advice (e.g. before, after) to add cross-cutting functionality like logging. AspectJ can weave aspects into bytecode at compile-time, post-compile, or load-time using a Java agent.
A comprehensive formal verification solution for ARM based SOC design chiportal
This document discusses Jasper's formal verification solutions for ARM processor-based system-on-chip (SoC) designs. It describes how Jasper can be used at the IP level to verify ARM Cortex processors and at the system level to verify aspects of full SoCs such as protocol verification, deadlock detection, and connectivity verification. Customers mentioned include Ericsson, Apple, Sony, and AMCC.
Migrating Legacy Waveforms to the Software Communications Architecture (SCA)ADLINK Technology IoT
This PrismTech Spectra software defined radio (SDR) webcast will discuss some of the challenges facing the migration or porting of an existing waveform to an Software Communications Architecture (SCA) radio system.
MDE based FPGA physical Design Fast prototyping with SmalltalkESUG
MDE based FPGA physical Design and Fast prototyping with Smalltalk. FPGAs are flexible hardware but can be hard to program due to the time needed to design, debug, and bring to market. EDA tools are required for circuit design, debugging, and benchmarking. The document discusses using a Smalltalk-based approach and MDE to address challenges with legacy EDA tools by shifting to a model-driven architecture and repository of reusable components to improve performance, scalability, flexibility and durability of the FPGA design process. Future work areas include integrating additional tools like Mondrian, and improving performance, test coverage and a graphical algorithm selection interface.
Spring Framework provides a comprehensive infrastructure to develop Java applications. It handles dependency injection and inversion of control so developers can focus on domain logic rather than plumbing. Spring promotes best practices like clean code, test-driven development, and design patterns. It includes aspects for cross-cutting concerns and supports web development through frameworks like Spring MVC. The document introduces Spring's lightweight and modular IoC container and AOP capabilities for separating concerns.
The document discusses attention mechanisms and their implementation in TensorFlow. It begins with an overview of attention mechanisms and their use in neural machine translation. It then reviews the code implementation of an attention mechanism for neural machine translation from English to French using TensorFlow. Finally, it briefly discusses pointer networks, an attention mechanism variant, and code implementation of pointer networks for solving sorting problems.
Aspect-Oriented Software Development (AOSD) is a programming methodology that addresses limitations in object-oriented programming for modularizing cross-cutting concerns. AOSD uses aspects to encapsulate cross-cutting concerns so they can be separated from the core functionality. Aspects are automatically incorporated into the system by a weaver. This improves modularity and makes software easier to maintain and evolve over time.
This document discusses how the Java Virtual Machine (JVM) can support multiple languages. It describes how language features can be emulated on the JVM through additional layers of indirection. It outlines key features added in JDK 7 like invokedynamic bytecode and method handles to better support dynamic languages on the JVM by reducing overhead from emulation. The document argues that the JVM should optimize for non-Java language features to benefit both Java and other languages running on the platform.
The FPGA design flow document outlines the typical steps for designing an FPGA including: 1) specification and system-level simulation, 2) device selection between Xilinx and Altera, 3) design entry using languages like Verilog and VHDL, 4) functional simulation, 5) synthesis, 6) placement and routing (P&R), 7) timing simulation, and 8) programming and debugging the final design on hardware.
The document summarizes the process of compiling Java code from writing it in an IDE to running the bytecode on a JVM. It discusses how code is compiled incrementally in an IDE, generated into bytecode, dynamically loaded and interpreted with just-in-time compilation into native code for performance. It also overview's IBM's involvement in Java development and optimization.
Why Have The Specifications Been Based On Java™ Technology? - P Kriensmfrancis
The OSGi specifications have been based on Java technology for several key reasons:
1) Java's use of interpreters makes it highly portable without requiring source code changes, as interpreters can easily be ported to new environments.
2) Java reduces security threats and improves stability by preventing illegal access to memory through exceptions and buffer overruns.
3) Java's versioning approach using symbolic links is more robust than traditional compiled languages that require specific version numbers.
4) Java finds type errors early through compilation, improving programmer productivity.
Непрерывное тестирование для улучшения качества кодаSQALab
Marcel Jankie is a solution architect for code quality at Micro Focus. Micro Focus offers several tools to help customers achieve better software faster through a proactive approach to requirement management, development, testing, and maintenance. Their tools integrate with development environments like Visual Studio, StarTeam, and Team Foundation Server to provide coverage analysis, automated testing, debugging, and system analysis capabilities. Micro Focus tools evolve over 25+ years of experience to help customers continuously integrate testing into their development process.
IBM Tokyo Research Laboratory has led research and development of Java language processing systems since the early days of Java, collaborating with IBM development divisions to deliver Java processing systems used as the foundation for business applications. The laboratory has proposed many advanced techniques implemented in just-in-time compilers and Java virtual machines, achieving world-class performance while conducting numerous academic presentations. This seminar describes experiences with research and development of commercial Java processing systems, covering topics like the introduction and adoption of Java, implementations of Java virtual machines and just-in-time compilers, and prospects for the future.
Upgrading to System Verilog for FPGA Designs, Srinivasan Venkataramanan, CVCFPGA Central
This document discusses upgrading FPGA designs to SystemVerilog. It presents an agenda that covers SystemVerilog constructs for RTL design, interfaces, assertions, and success stories. It then discusses the SystemVerilog-FPGA ecosystem. The presenter has over 13 years of experience in VLSI design and verification and has authored books on verification topics including SystemVerilog assertions. SystemVerilog is a superset of Verilog-2001 and offers enhanced constructs for modeling logic, interfaces, testbenches and connecting to C/C++.
ScalableCore System: A Scalable Many-core Simulator by Employing Over 100 FPGAsShinya Takamaeda-Y
The document summarizes a presentation about the ScalableCore System, a scalable many-core simulator that employs over 100 FPGAs. It maps a target many-core processor across multiple FPGA boards, each simulating a tile/core. This allows achieving scalable simulation speeds as the number of target cores increases. Evaluation shows the resource usage and faster simulation speeds compared to software simulators as the number of simulated nodes increases from 16 to 100.
A Java Implementer's Guide to Boosting Apache Spark Performance by Tim Ellison.J On The Beach
Apache Spark has rocked the big data landscape, quickly becoming the largest open source big data community with over 750 contributors from more than 200 organizations. Spark's core tenants of speed, ease of use, and its unified programming model fit neatly with the high performance, scalable, and manageable characteristics of modern Java runtimes. In this talk we introduce the Spark programming model, and describe some unique Java runtime capabilities in the JIT, fast networking, serialization techniques, and GPU off-loading that deliver the ultimate big data platform for solving business problems. We will show how solutions, previously infeasible with regular Java programming, become possible with a high performance Spark core runtime, enabling you to solve problems smarter and faster.
This paper presents an improved hardware acceleration scheme for Java method calls in the REALJava coprocessor. The strategy is implemented in an FPGA prototype and allows for measuring real performance increases. It validates the coprocessor concept for accelerating Java bytecode execution in embedded systems with limited CPU performance and memory availability. The coprocessor architecture is highly modular, separating communication from the execution core to improve reusability and allow for system scalability.
Spring is a Java application framework that provides comprehensive infrastructure support for developing Java applications. It includes modules for core functions, data access, MVC web apps, and other aspects like AOP. The core provides dependency injection and IoC. The DAO module abstracts JDBC coding. The ORM module integrates ORMs. The MVC module provides a MVC structure for webapps. AOP allows separating cross-cutting concerns. Using Spring promotes loose coupling, separation of concerns, and testability. It also supports integration with popular technologies and allows flexible usage of individual modules.
It seems like keeping up to date with Java nowadays can be a daunting task. Gone is the era of big, delayed Java releases that span years. We’re now getting a new major release every six months. What’s up with that? You’re probably still developing on Java 8, even though Java 13 is almost released already. Attend this session to get a code-first overview of what’s new in Java since Java 8. You’ll get an overview of the module system (Java 9), the local variable type inference feature (Java 10), and the new HttpClient API (Java 11), plus a sneak peek of Java 12 and 13 preview features. It’s time to embrace the newfound agility of the Java platform!
It seems like keeping up to date with Java nowadays is an enormous task. Gone is the era of big, delayed Java releases that span years. We're now getting a new major release every six months. What's up with that? You're probably still developing on Java 8, even though Java 12 is already available.
Join this session to get a code-first overview of what's new in Java since Java 8. We'll give an overview of the module system (Java 9), the local-variable type inference feature (Java 10), the new HttpClient API (Java 11) and a sneak peek of Switch Expressions in Java 12. Expect lots of advice on what to expect when migrating beyond Java 8. It's time to embrace the newfound agility of the Java platform!
In September 2017 the long-awaited release of Java 9 gave us a new module system in Java. It also kick-started the release-train of frequent Java releases, with Java 11 being the first long-term supported Java version poised to take modules into the mainstream. So what has happened since the introduction of the module system?
This talk will provide an overview adoption of modules in open-source libraries, IDEs, build tools, and so on. It will also feature tools that have emerged to make working with modules easier. Expect an honest overview of the current state of modules in Java, with lots of demos to show what's possible. After this talk you can start developing your own modular Java application without hesitation!
Java 9 brings modules as a core concept to the platform, but it’s more than just a language feature. With modules in Java 9, we can improve the design of code to increase maintainability and extensibility. As with every design principle, modularity requires thought and trade-offs to really reap the benefits. This session covers design practices for making codebases more maintainable and extensible. You will also find out about trade-offs to help you make the best choices. Topics include hiding implementations, using services for extensibility, API modules, avoiding cycles, optional dependencies, and dynamically loading modules. Familiarity with modules is helpful but not required. The speakers are the authors of Java 9 Modularity (O’Reilly).
Also see https://javamodularity.com
Microservices promise a scalable architecture, increased flexibility, and better performance. But then you find out what’s actually involved in designing, developing, and running a microservices-based architecture. It turns out it’s not that straightforward after all.
Often the discussion around microservices is framed by a false dichotomy between the messy monolith and the lean and mean microservices architecture. Sander Mak explains that there’s a third way: the modularized application. Functional decomposition of your application doesn’t imply that every component has to become its own independent process.
Modularization is about strong encapsulation, well-defined interfaces, and explicit dependencies. Many languages offer in-process modularization features (for example, Java 9 with its upcoming module system), and there’s a strong overlap between the microservices philosophy and development benefits—without incurring the penalty of operational complexity.
Sander explores the right (and wrong) reasons for going with a microservices architecture, as well as what a modularized application entails. You’ll see that splitting up an existing service or application into microservices isn’t always the clear winner. You’ll leave able to choose between the alternatives for the right reasons. There’s a place for both independently deployed microservices and larger applications with a strong internal modular structure. Choose wisely.
With Java 9 modules coming to us soon, you want your existing code to be fully ready for the module system. Making code modular can be a daunting task, but Java 9 comes with a number features to ease migration. This includes automatic modules, the unnamed module and a number of command line arguments.
In this talk we will look at examples of migrating real code. It discusses common problems youll run into during migration, leading to practical tips and the ability to set realistic goals. Its also a good way to understand the module system itself and the various migration paths it supports. This talk is an excellent preparation to start migrating your own code.
* Understanding modules and the module path
* Automatic modules
* Mixing classpath and modulepath
* Dealing with reflection
* Escape switches
* Jdeps
All topics will be based on examples of often used libraries and frameworks.
With Java 9, modularity comes to your doorstep (whether you ordered it or not). This isn't your average language feature: making the most out of it may involve rewiring your brain. In this session we explore the benefits of a modular codebase using Java 9 modules. Because who doesn’t like more reliable and secure applications, meanwhile killing the dreaded classpath?
After reviewing the basic concepts of modules, we'll explore modularity patterns that enhance your design and development skills. We all have existing software, so migration of codebases to a modular world is an important topic as well. Automatic modules and other new concepts are added to your toolbox to this end.
Want examples? We've got plenty in this practical and code-driven talk. Even if you intend to use Java 9 without modules, this talk helps you prevent common issues. You'll be ready for Java 9 before you know it.
Both speakers are currently writing “Java 9 Modularity” for O’Reilly, expected early 2017. They have extensive experience under the belt already with the Java 9 Jigsaw early access builds.
With modularity coming to the core Java platform in Java 9, are all our modularity needs fulfilled, or does it still make sense to use something like OSGi? In this talk you will learn how Jigsaw helps modularity, and in what cases it might fall short.
Java 9 will provide a module-system, called Jigsaw. Besides modularising the JDK itself, Java developers can build more modular applications with Jigsaw. Modularity and Java go back way longer, though. OSGi, the de facto standard for modularity in Java has been around since 2000. Adoption is increasing in recent years.
A modular architecture has many advantages, such as increased decoupling resulting in more flexibility. In that sense, native support for Java modularity is very welcome. The big question now is: does Java 9 provide everything you need to build truly modular applications? Since Java 9 needs to maintain backwards compatibility, some compromises need to be made while enforcing module boundaries.
This talk discusses what you really need to build modular applications. We'll investigate which requirements are met (or not) by both module systems. You'll see that both Jigsaw and OSGi provided pieces of the modularity puzzle. Also, you'll learn whether having an additional modular runtime such as OSGi on top of Java 9 still makes sense.
How do we get our software out on the Internet of Things? Many assumptions in current deployment practices don't hold up. Devices can be occasionally connected, through low-bandwidth networks and are generally outside of direct control. Manually shuffling around binaries is not an option.
Apache ACE is an open-source Java provisioning tool tackling such challenges.You can manage Java apps and configs in a modular fashion. The foundations of ACE are OSGi, semantic versioning and reliable communication. Pushing out incremental updates and managing numerous devices becomes possible.
Slides for my talk event-sourced architectures with Akka. Discusses Akka Persistence as mechanism to do event-sourcing. Presented at Javaone 2014 and Jfokus 2015.
This document discusses TypeScript, a superset of JavaScript that adds optional static typing and class-based object-oriented programming. It allows developers to gradually introduce typing into JavaScript code for improved productivity and catch errors early. The document covers TypeScript features like interfaces, classes, modules, type definitions, and comparisons to alternatives like CoffeeScript and Dart. It concludes that TypeScript allows gradual adoption of typing while following the future ECMAScript standard.
Working with micro-services is arguably the best part of OSGi development. However, everyone agrees that tracking service dependencies with the bare-bones OSGi API is not ideal. So, you pick one of the available dependency managers: either Declarative Services, Felix Dependency manager, Blueprint or iPojo.
But how do you pick the right one? Easy! After this shoot-out you’ll know all about the performance, usability and other aspects of the existing dependency managers. We show the strengths and weaknesses of the implementations side-by-side. How usable is the API? What about performance, does it scale beyond trivial amounts of services? Does it matter which OSGi framework you run the dependency manager in?
Make up your mind with the facts presented in this session.
The document discusses JavaScript modularity and module systems. It describes some of the challenges of modularity in JavaScript, like globals and namespacing issues. It then compares different module systems for JavaScript like AMD, CommonJS, and ES6 modules. RequireJS is presented as a robust implementation of the AMD specification that supports features like lazy-loading and backwards compatibility. The document advocates picking one module system and sticking with it for consistency.
This document discusses how modularity was used to build an educational software system called PulseOn in a scalable way for the cloud. Some key points:
- PulseOn was divided into multiple modules (bundles) like personal dashboards, learning content, adaptive recommendations, etc. that communicated through well-defined interfaces.
- Technologies like OSGi, RESTful APIs, MongoDB, and HTML5/JavaScript were used to build these modular and interoperable components.
- The system was designed to automatically scale on demand across multiple servers using load balancers and auto-scaling groups.
- Open-source tools like Amdatu and Apache ACE helped with building and deploying modular cloud-
Cross-Build Injection attacks are a completely new class of attacks that take place at build time. In this presentation (which was presented at JavaOne 2012) I show what the problem is and what can be done about. As always, security doesn't come for free: you'll have to work to get it right!
(unfortunately, some graphics got mangled by the SlideShare conversion. Sorry!)
'Elevate your webapps with Scala & Lift', as presented on JEEConf 2012, Kiev, Ukraine
Also see: http://branchandbound.net/blog/conferences/2012/05/jeeconf-tripreport/
Hibernate Performance Tuning, presented on JEEConf 2012, Kiev, Ukraine.
Also see: http://branchandbound.net/blog/conferences/2012/05/jeeconf-tripreport/
Adaptation of presentation at http://www.slideshare.net/SanderMak/hibernate-performance-tuning
Introduction to Akka, as presented on May 3 2012 at the Belgian Java User Group (BeJUG). For more details see: http://www.bejug.org/confluenceBeJUG/display/BeJUG/ForkJoin+and+Akka
Demo code can be found at: http://bit.ly/bejug-akka
Introduction to JDK7's Fork/Join framework. Present on May 3 2012 at the Belgian Java User Group (BeJUG). For more information see: http://www.bejug.org/confluenceBeJUG/display/BeJUG/ForkJoin+and+Akka
Demo code can be found at http://bit.ly/bejug-fj
HCL Notes und Domino Lizenzkostenreduzierung in der Welt von DLAUpanagenda
Webinar Recording: https://www.panagenda.com/webinars/hcl-notes-und-domino-lizenzkostenreduzierung-in-der-welt-von-dlau/
DLAU und die Lizenzen nach dem CCB- und CCX-Modell sind für viele in der HCL-Community seit letztem Jahr ein heißes Thema. Als Notes- oder Domino-Kunde haben Sie vielleicht mit unerwartet hohen Benutzerzahlen und Lizenzgebühren zu kämpfen. Sie fragen sich vielleicht, wie diese neue Art der Lizenzierung funktioniert und welchen Nutzen sie Ihnen bringt. Vor allem wollen Sie sicherlich Ihr Budget einhalten und Kosten sparen, wo immer möglich. Das verstehen wir und wir möchten Ihnen dabei helfen!
Wir erklären Ihnen, wie Sie häufige Konfigurationsprobleme lösen können, die dazu führen können, dass mehr Benutzer gezählt werden als nötig, und wie Sie überflüssige oder ungenutzte Konten identifizieren und entfernen können, um Geld zu sparen. Es gibt auch einige Ansätze, die zu unnötigen Ausgaben führen können, z. B. wenn ein Personendokument anstelle eines Mail-Ins für geteilte Mailboxen verwendet wird. Wir zeigen Ihnen solche Fälle und deren Lösungen. Und natürlich erklären wir Ihnen das neue Lizenzmodell.
Nehmen Sie an diesem Webinar teil, bei dem HCL-Ambassador Marc Thomas und Gastredner Franz Walder Ihnen diese neue Welt näherbringen. Es vermittelt Ihnen die Tools und das Know-how, um den Überblick zu bewahren. Sie werden in der Lage sein, Ihre Kosten durch eine optimierte Domino-Konfiguration zu reduzieren und auch in Zukunft gering zu halten.
Diese Themen werden behandelt
- Reduzierung der Lizenzkosten durch Auffinden und Beheben von Fehlkonfigurationen und überflüssigen Konten
- Wie funktionieren CCB- und CCX-Lizenzen wirklich?
- Verstehen des DLAU-Tools und wie man es am besten nutzt
- Tipps für häufige Problembereiche, wie z. B. Team-Postfächer, Funktions-/Testbenutzer usw.
- Praxisbeispiele und Best Practices zum sofortigen Umsetzen
5th LF Energy Power Grid Model Meet-up SlidesDanBrown980551
5th Power Grid Model Meet-up
It is with great pleasure that we extend to you an invitation to the 5th Power Grid Model Meet-up, scheduled for 6th June 2024. This event will adopt a hybrid format, allowing participants to join us either through an online Mircosoft Teams session or in person at TU/e located at Den Dolech 2, Eindhoven, Netherlands. The meet-up will be hosted by Eindhoven University of Technology (TU/e), a research university specializing in engineering science & technology.
Power Grid Model
The global energy transition is placing new and unprecedented demands on Distribution System Operators (DSOs). Alongside upgrades to grid capacity, processes such as digitization, capacity optimization, and congestion management are becoming vital for delivering reliable services.
Power Grid Model is an open source project from Linux Foundation Energy and provides a calculation engine that is increasingly essential for DSOs. It offers a standards-based foundation enabling real-time power systems analysis, simulations of electrical power grids, and sophisticated what-if analysis. In addition, it enables in-depth studies and analysis of the electrical power grid’s behavior and performance. This comprehensive model incorporates essential factors such as power generation capacity, electrical losses, voltage levels, power flows, and system stability.
Power Grid Model is currently being applied in a wide variety of use cases, including grid planning, expansion, reliability, and congestion studies. It can also help in analyzing the impact of renewable energy integration, assessing the effects of disturbances or faults, and developing strategies for grid control and optimization.
What to expect
For the upcoming meetup we are organizing, we have an exciting lineup of activities planned:
-Insightful presentations covering two practical applications of the Power Grid Model.
-An update on the latest advancements in Power Grid -Model technology during the first and second quarters of 2024.
-An interactive brainstorming session to discuss and propose new feature requests.
-An opportunity to connect with fellow Power Grid Model enthusiasts and users.
In the rapidly evolving landscape of technologies, XML continues to play a vital role in structuring, storing, and transporting data across diverse systems. The recent advancements in artificial intelligence (AI) present new methodologies for enhancing XML development workflows, introducing efficiency, automation, and intelligent capabilities. This presentation will outline the scope and perspective of utilizing AI in XML development. The potential benefits and the possible pitfalls will be highlighted, providing a balanced view of the subject.
We will explore the capabilities of AI in understanding XML markup languages and autonomously creating structured XML content. Additionally, we will examine the capacity of AI to enrich plain text with appropriate XML markup. Practical examples and methodological guidelines will be provided to elucidate how AI can be effectively prompted to interpret and generate accurate XML markup.
Further emphasis will be placed on the role of AI in developing XSLT, or schemas such as XSD and Schematron. We will address the techniques and strategies adopted to create prompts for generating code, explaining code, or refactoring the code, and the results achieved.
The discussion will extend to how AI can be used to transform XML content. In particular, the focus will be on the use of AI XPath extension functions in XSLT, Schematron, Schematron Quick Fixes, or for XML content refactoring.
The presentation aims to deliver a comprehensive overview of AI usage in XML development, providing attendees with the necessary knowledge to make informed decisions. Whether you’re at the early stages of adopting AI or considering integrating it in advanced XML development, this presentation will cover all levels of expertise.
By highlighting the potential advantages and challenges of integrating AI with XML development tools and languages, the presentation seeks to inspire thoughtful conversation around the future of XML development. We’ll not only delve into the technical aspects of AI-powered XML development but also discuss practical implications and possible future directions.
TrustArc Webinar - 2024 Global Privacy SurveyTrustArc
How does your privacy program stack up against your peers? What challenges are privacy teams tackling and prioritizing in 2024?
In the fifth annual Global Privacy Benchmarks Survey, we asked over 1,800 global privacy professionals and business executives to share their perspectives on the current state of privacy inside and outside of their organizations. This year’s report focused on emerging areas of importance for privacy and compliance professionals, including considerations and implications of Artificial Intelligence (AI) technologies, building brand trust, and different approaches for achieving higher privacy competence scores.
See how organizational priorities and strategic approaches to data security and privacy are evolving around the globe.
This webinar will review:
- The top 10 privacy insights from the fifth annual Global Privacy Benchmarks Survey
- The top challenges for privacy leaders, practitioners, and organizations in 2024
- Key themes to consider in developing and maintaining your privacy program
UiPath Test Automation using UiPath Test Suite series, part 6DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 6. In this session, we will cover Test Automation with generative AI and Open AI.
UiPath Test Automation with generative AI and Open AI webinar offers an in-depth exploration of leveraging cutting-edge technologies for test automation within the UiPath platform. Attendees will delve into the integration of generative AI, a test automation solution, with Open AI advanced natural language processing capabilities.
Throughout the session, participants will discover how this synergy empowers testers to automate repetitive tasks, enhance testing accuracy, and expedite the software testing life cycle. Topics covered include the seamless integration process, practical use cases, and the benefits of harnessing AI-driven automation for UiPath testing initiatives. By attending this webinar, testers, and automation professionals can gain valuable insights into harnessing the power of AI to optimize their test automation workflows within the UiPath ecosystem, ultimately driving efficiency and quality in software development processes.
What will you get from this session?
1. Insights into integrating generative AI.
2. Understanding how this integration enhances test automation within the UiPath platform
3. Practical demonstrations
4. Exploration of real-world use cases illustrating the benefits of AI-driven test automation for UiPath
Topics covered:
What is generative AI
Test Automation with generative AI and Open AI.
UiPath integration with generative AI
Speaker:
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
Let's Integrate MuleSoft RPA, COMPOSER, APM with AWS IDP along with Slackshyamraj55
Discover the seamless integration of RPA (Robotic Process Automation), COMPOSER, and APM with AWS IDP enhanced with Slack notifications. Explore how these technologies converge to streamline workflows, optimize performance, and ensure secure access, all while leveraging the power of AWS IDP and real-time communication via Slack notifications.
Cosa hanno in comune un mattoncino Lego e la backdoor XZ?Speck&Tech
ABSTRACT: A prima vista, un mattoncino Lego e la backdoor XZ potrebbero avere in comune il fatto di essere entrambi blocchi di costruzione, o dipendenze di progetti creativi e software. La realtà è che un mattoncino Lego e il caso della backdoor XZ hanno molto di più di tutto ciò in comune.
Partecipate alla presentazione per immergervi in una storia di interoperabilità, standard e formati aperti, per poi discutere del ruolo importante che i contributori hanno in una comunità open source sostenibile.
BIO: Sostenitrice del software libero e dei formati standard e aperti. È stata un membro attivo dei progetti Fedora e openSUSE e ha co-fondato l'Associazione LibreItalia dove è stata coinvolta in diversi eventi, migrazioni e formazione relativi a LibreOffice. In precedenza ha lavorato a migrazioni e corsi di formazione su LibreOffice per diverse amministrazioni pubbliche e privati. Da gennaio 2020 lavora in SUSE come Software Release Engineer per Uyuni e SUSE Manager e quando non segue la sua passione per i computer e per Geeko coltiva la sua curiosità per l'astronomia (da cui deriva il suo nickname deneb_alpha).
How to Get CNIC Information System with Paksim Ga.pptxdanishmna97
Pakdata Cf is a groundbreaking system designed to streamline and facilitate access to CNIC information. This innovative platform leverages advanced technology to provide users with efficient and secure access to their CNIC details.
Unlock the Future of Search with MongoDB Atlas_ Vector Search Unleashed.pdfMalak Abu Hammad
Discover how MongoDB Atlas and vector search technology can revolutionize your application's search capabilities. This comprehensive presentation covers:
* What is Vector Search?
* Importance and benefits of vector search
* Practical use cases across various industries
* Step-by-step implementation guide
* Live demos with code snippets
* Enhancing LLM capabilities with vector search
* Best practices and optimization strategies
Perfect for developers, AI enthusiasts, and tech leaders. Learn how to leverage MongoDB Atlas to deliver highly relevant, context-aware search results, transforming your data retrieval process. Stay ahead in tech innovation and maximize the potential of your applications.
#MongoDB #VectorSearch #AI #SemanticSearch #TechInnovation #DataScience #LLM #MachineLearning #SearchTechnology
Main news related to the CCS TSI 2023 (2023/1695)Jakub Marek
An English 🇬🇧 translation of a presentation to the speech I gave about the main changes brought by CCS TSI 2023 at the biggest Czech conference on Communications and signalling systems on Railways, which was held in Clarion Hotel Olomouc from 7th to 9th November 2023 (konferenceszt.cz). Attended by around 500 participants and 200 on-line followers.
The original Czech 🇨🇿 version of the presentation can be found here: https://www.slideshare.net/slideshow/hlavni-novinky-souvisejici-s-ccs-tsi-2023-2023-1695/269688092 .
The videorecording (in Czech) from the presentation is available here: https://youtu.be/WzjJWm4IyPk?si=SImb06tuXGb30BEH .
Skybuffer SAM4U tool for SAP license adoptionTatiana Kojar
Manage and optimize your license adoption and consumption with SAM4U, an SAP free customer software asset management tool.
SAM4U, an SAP complimentary software asset management tool for customers, delivers a detailed and well-structured overview of license inventory and usage with a user-friendly interface. We offer a hosted, cost-effective, and performance-optimized SAM4U setup in the Skybuffer Cloud environment. You retain ownership of the system and data, while we manage the ABAP 7.58 infrastructure, ensuring fixed Total Cost of Ownership (TCO) and exceptional services through the SAP Fiori interface.
Have you ever been confused by the myriad of choices offered by AWS for hosting a website or an API?
Lambda, Elastic Beanstalk, Lightsail, Amplify, S3 (and more!) can each host websites + APIs. But which one should we choose?
Which one is cheapest? Which one is fastest? Which one will scale to meet our needs?
Join me in this session as we dive into each AWS hosting service to determine which one is best for your scenario and explain why!
Project Management Semester Long Project - Acuityjpupo2018
Acuity is an innovative learning app designed to transform the way you engage with knowledge. Powered by AI technology, Acuity takes complex topics and distills them into concise, interactive summaries that are easy to read & understand. Whether you're exploring the depths of quantum mechanics or seeking insight into historical events, Acuity provides the key information you need without the burden of lengthy texts.
1. Advice weaving in AspectJ
Advice weaving in AspectJ
AOP Seminar - Session 7
Sander Mak
Center for Software Technology, Universiteit Utrecht
December 6, 2006
Center for Software Technology Sander Mak
2. Advice weaving in AspectJ
Outline
Introduction
1
JVM bytecode
2
Weaving in AspectJ
3
Weaving in Aspect Bench
4
Semantics of static pointcuts
5
Conclusion
6
Questions
7
Center for Software Technology Sander Mak
3. Advice weaving in AspectJ > Introduction
AspectJ
Most widely used aspect language and compiler for Java
Eclipse community project
Large contributions by IBM
Goals:
Create a stable aspect language for Java
1
Provide a production quality compiler
2
Create supporting tools for AO development
3
Center for Software Technology Sander Mak
4. Advice weaving in AspectJ > Introduction
Paper: Advice Weaving in AspectJ
By Erik Hilsdale and Jim Hugunin (both AspectJ developers)
Based on 1.1 (current branch: 1.5)
almost everything still applicable
except for performance indicators
Paper’s focus: finding pointcuts, weaving advice in ajc
Additionally, benchmarks are performed
Most recent implementation paper from AspectJ team
Why focus on the the weaver?
It’s complex: 82/131 of open AspectJ bugreports are weaver-related ...
... but it’s interesting!
Center for Software Technology Sander Mak
5. Advice weaving in AspectJ > JVM bytecode
Bytecode class contents
A compiled Java class can be divided into 2 sections:
Constant pool Bytecode
Class name Instructions
Method names Per method
Method signatures (e.g. I(IL)) Stack based
Constants Weakly typed (checks are
enforced though)
Field references
Fully qualified names
Arbitrary attributes
Center for Software Technology Sander Mak
6. Advice weaving in AspectJ > JVM bytecode
JVM Overview
Center for Software Technology Sander Mak
7. Advice weaving in AspectJ > JVM bytecode
Stackframes
Every currently executing method has a frame on the stack:
Local variable store
Unique indices
Operand stack for expression
evaluation
Pointer to constant pool
Center for Software Technology Sander Mak
8. Advice weaving in AspectJ > JVM bytecode
Example
Test.java
public class Test implements SomeInterface {
public void main(String[] args){
int i;
i = 1;
String s = args[0];
int j = 1 + i; }
}
Center for Software Technology Sander Mak
9. Advice weaving in AspectJ > JVM bytecode
Example
Bytecode
Test.java
public class Test implements SomeInterface {
public void main(String[] args){
int i;
i = 1;
String s = args[0];
int j = 1 + i; }
}
Center for Software Technology Sander Mak
10. Advice weaving in AspectJ > Weaving in AspectJ
Terminology
Before moving on, let’s revisit some of the AOP terms:
pointcut Pattern describing events based on matching static code
and doing dynamic checks
joinpoint Actual intercepted runtime events (point in execution
graph)
shadow Region of code belonging to a joinpoint (statically
determinable)
advice Additional code executed at joinpoint
Center for Software Technology Sander Mak
11. Advice weaving in AspectJ > Weaving in AspectJ
Implementing AOP
In general, there are several options to implement the AOP paradigm:
Combine (weave) advice at compile time with original program
Restricts joinpoint model considerably
Or needs to be supplemented with runtime system
Modify runtime environment to support joinpoint model
dynamically
For example: add hooks to virtual machine
Complete freedom of joinpoint model, but at high costs
Some languages: implement using reflection
As above, probably even worse
Load-time weaving, e.g. using custom ClassLoaders in Java
Center for Software Technology Sander Mak
12. Advice weaving in AspectJ > Weaving in AspectJ
ajc architecture
Parse Java+AspectJ
1
Compile advice into
2
methods (and annotate)
Annotate shadows based
3
on pointcut declarations
Weave advice
4
Emit Java bytecode
5
Various optimizations left out
Java 1.5 Annotations can
replace front-end
Center for Software Technology Sander Mak
13. Advice weaving in AspectJ > Weaving in AspectJ
Compiling advice
Body of advice is put in a method
Environment information is added to signature
Parameters to the advice
JoinPoint and JoinPoint.StaticPart
Optimization: leave either one out, or replace with StaticPart
Contents of environment pruned for optimization
Reflective information is expensive as it involves:
Object creation
Casting arrays of arguments (can have complexity O(n))
Special case: around advice with proceed calls
ProceedJoinPoint holds AroundClosure
Contains information to resume normal operation from within
advice
Implemented as Object-array containing surrounding free variables
Center for Software Technology Sander Mak
14. Advice weaving in AspectJ > Weaving in AspectJ
Finding shadows
To weave advice, we must locate the execution points in code:
shadows
Match pointcut of each advice to joinpoints (O(s·a))
On match: modify bytecode to call advice
Calling advice
Create necessary context
1
Possibly store arguments
2
Add:
3
invokestatic [A.aspectOf]
invokevirtual [ajc$pointcut$advicename]
Context sensitive pointcuts leave dynamic residue
Center for Software Technology Sander Mak
15. Advice weaving in AspectJ > Weaving in AspectJ
FastMatchTM
Time complexity can get out of hand. Therefore ajc should optimize:
Leveraging information from a classes’ constant pool:
Class name Fully qualified classname, to check within pointcut
Method names check for matching pointcuts
Method signatures find applicable methods without scanning whole class
Field references check for matching set/get pointcuts
In 1.1 only the first optimization is applied
Center for Software Technology Sander Mak
16. Advice weaving in AspectJ > Weaving in AspectJ
Question: Gerbo
Could you elaborate a bit on the fastmatch pass? It seems quite vital
for compilation efficiency, but the authors go over it quite fast. Also
-two years after the paper-, did they implement fastmatch for more
PCDs than within, and did they implement the optimization they
mention? And if so, does compilation perform significantly better?
Center for Software Technology Sander Mak
17. Advice weaving in AspectJ > Weaving in AspectJ
Question: Gerbo
Could you elaborate a bit on the fastmatch pass? It seems quite vital
forQuestion of Nabil as well: the authors go over it quite fast. Also
compilation efficiency, but
Why isnt fastmatch used to implement other PCDs such Construc-
-two years after the paper-, did they implement fastmatch for more
PCDs than within, and did they informationthe optimization they these
tor/method execution? All the implement needed for to match
mention? And if so, present in the constant pool information.
example PCDs is does compilation perform significantly better?
Leaving out FastMatch for within gave 256% increase in
compiletime
It would be natural to add others:
hard to find out what’s really done
I emailed the authors, so far no response :-(
Bugzilla does mention ’some’ FastMatch additions
but 1.2 was already twice as fast, 1.5 even better
Other optimization (kinded joinpoints) has been implemented
Center for Software Technology Sander Mak
18. Advice weaving in AspectJ > Weaving in AspectJ
Question: Gerbo
Center for Software Technology Sander Mak
19. Advice weaving in AspectJ > Weaving in AspectJ
Shadow mungers
to munge - The Jargon File
muhnj [derogatory] 1. To imperfectly transform information. 2. A
comprehensive rewrite of a routine, datastructure or the whole
program. 3. To modify data in some way the speaker doesn’t need to
go into right now or cannot describe succinctly (compare mumble)
A shadow munger describes a translation strategy for every type of
advice.
Paper gives informal descriptions
And some examples of the 2-step process:
Expose context
1
Inject desired behavior
2
Center for Software Technology Sander Mak
20. Advice weaving in AspectJ > Weaving in AspectJ
Shadow mungers
Transform shadow within
boundary
Ensures compositionality
Apply in inverse precedence
order
Precedence rules are complex,
and are user-definable as of
1.5
Center for Software Technology Sander Mak
21. Advice weaving in AspectJ > Weaving in AspectJ
Shadow mungers
Transform returns to
unconditional jump
Add call to advice at result
label
Of course: add correct return
Alternative: inline advice call
before each return statement
Center for Software Technology Sander Mak
22. Advice weaving in AspectJ > Weaving in AspectJ
Dynamic Residue
Not everything can be determined at compile time:
Polymorphism
public void interceptMe(Object a) {..}
-- aspect:
before(): execution(* interceptMe(String)) {..}
Center for Software Technology Sander Mak
23. Advice weaving in AspectJ > Weaving in AspectJ
Dynamic Residue
Not everything can be determined at compile time:
Polymorphism
public void interceptMe(Object a) {..}
-- aspect:
Problem:
before(): execution(* interceptMe(String)) {..}
interceptMe(Object a) matches, but:
Runtime check necessary to see whether the object is of type
String:
instanceof [String]
ifeq jump to label
..advice..
jump to label:
..normal code..
If Object were Integer, we can statically decide against the
advice
Center for Software Technology Sander Mak
24. Advice weaving in AspectJ > Weaving in AspectJ
Dynamic Residue
Not everything can be determined at compile time:
Polymorphism
public void interceptMe(Object a) {..}
-- aspect:
before(): execution(* interceptMe(String)) {..}
If pointcut
Every If check results in dynamic checking code
Partial evaluation could improve this (at higher costs)
Example: if(Tracing.level==1)
Center for Software Technology Sander Mak
25. Advice weaving in AspectJ > Weaving in AspectJ
Dynamic Residue
Not everything can be determined at compile time:
Polymorphism
public void interceptMe(Object a) {..}
-- aspect:
before(): execution(* interceptMe(String)) {..}
If pointcut
Every If check results in dynamic checking code
Partial evaluation could improve this (at higher costs)
Example: if(Tracing.level==1)
this/target
Both could leave dynamic instanceof residue
Center for Software Technology Sander Mak
26. Advice weaving in AspectJ > Weaving in AspectJ
Dynamic Residue
cflow is notoriously expensive:
ajc has to insert code that manipulates a call-stack at runtime
entry/exit recorded on stack in ThreadLocal variable
advice can inspect stack to check applicability of cflow pointcut
in a joinpoint
this administration brings much overhead
Stackless implementation using sophisticated guards/counters is in
progress (OOPSLA paper 2006)
Center for Software Technology Sander Mak
27. Advice weaving in AspectJ > Weaving in AspectJ
Drawbacks of ajc
Due to implementation of weaving there are some operation
restrictions:
End of exception handler is not explicit in bytecode: no after or
around advice possible
Only bytecode ’controlled’ by ajc can be woven: declare
parents : String implements MyInterface will not work
Reflective calls are not intercepted (semantically you could argue
this is bad)
Center for Software Technology Sander Mak
28. Advice weaving in AspectJ > Weaving in AspectJ
Drawbacks of ajc
Due to implementation of weaving there are some operation
restrictions:
End of exception handler is not explicit in bytecode: no after or
around advice possible
Only bytecode ’controlled’ by ajc can be woven: declare
parents : String implements MyInterface will not work
Reflective calls are not intercepted (semantically you could argue
this is bad)
Java source/bytecode mismatch
translated by Java compiler as:
String foo = s + quot;aquot;;
String foo = s.append(quot;aquot;);
aspect: before() : execution(* append(*)) {..}
Center for Software Technology Sander Mak
29. Advice weaving in AspectJ > Weaving in AspectJ
Drawbacks of ajc
Dependencies:
A heavily customized version of ecj
also the reason why it takes so long to adapt ajc to new Eclipse
releases
changes are not trivial: at least 44 Java source files involved
parser is ’hacked’ to handle pointcuts
Apache BCEL
modified version is used
BCEL is no longer maintained, so ajc maintains it
(as of june this year this might have changed)
Somewhat vague semantics (shadow mungers)
In general: ad-hoc, non-extensible, but fast implementation
Center for Software Technology Sander Mak
30. Advice weaving in AspectJ > Weaving in Aspect Bench
Introduction
Based on:
abc: an extensible AspectJ compiler P. Avgustinov, O. de Moor
The Aspect Bench Compiler is a research compiler with the following
goals:
clean seperation of front-end/back-end
extensible typesystem, matcher and weaver
painless code generation
allow for pointcut selection based on semantics instead of naming
Center for Software Technology Sander Mak
31. Advice weaving in AspectJ > Weaving in Aspect Bench
Architecture
Front-end: Polyglot
Extensible parser and AST representation
Syntax can be extended by defining modifications externally
Built to be extended
Back-end: Soot
Intermediate language: Jimple
Typed, stackless bytecode representation
Bytecode generation
Bytecode analysis and optimization
All used in standard, non-modified way
Center for Software Technology Sander Mak
32. Advice weaving in AspectJ > Weaving in Aspect Bench
Bytecode vs. Jimple weaving
Center for Software Technology Sander Mak
33. Advice weaving in AspectJ > Weaving in Aspect Bench
Weaving
Is generally much easier to specify in Jimple:
Implicit execution stack is handled by stackless representation
Optimization largely done by Soot, can be removed from
translation
Type information available everywhere
Defensive copying of context by ajc is avoided, resulting in better
performing code
Center for Software Technology Sander Mak
34. Advice weaving in AspectJ > Weaving in Aspect Bench
Extensions
All extension can be made without modifying the existing AspectJ
implementation
Examples that are implemented:
Private pointcut vars Variables scoped over pointcut only
Cast pointcut Intercept typecasts
Global pointcuts e.g. global : * : !within(HiddenClass)
AspectJ still compiles faster, but generates less optimized code
Center for Software Technology Sander Mak
35. Advice weaving in AspectJ > Semantics of static pointcuts
Introduction
Based on:
Semantics of Static Pointcuts in AspectJ P. Avgustinov et al.
Fundamental research on pointcuts:
extendability
formalization
Submitted to POPL 2007
Center for Software Technology Sander Mak
36. Advice weaving in AspectJ > Semantics of static pointcuts
Why?
Reasons to study a formal semantics for pointcuts:
Observation
Point Cut Designators (PCD) form a language of their own; and it is
already very expressive
Center for Software Technology Sander Mak
37. Advice weaving in AspectJ > Semantics of static pointcuts
Why?
Reasons to study a formal semantics for pointcuts:
Observation
Point Cut Designators (PCD) form a language of their own; and it is
already very expressive
focus of research has been: semantics of advice or semantics of
’easy’ pointcut language
Lots of subtleties and corner-cases
Not desirable to depend on implementation (AspectJ) for
specification
A formal semantics gives baseline to evaluate and improve
implementations
Complexity is a continuing source of serious bugs in AspectJ
Gives foundation to discussion of language extensions
I will try to give the flavor of the paper
Center for Software Technology Sander Mak
38. Advice weaving in AspectJ > Semantics of static pointcuts
Approach
Translate surface language (AspectJ+PCD) to core language
Center for Software Technology Sander Mak
39. Advice weaving in AspectJ > Semantics of static pointcuts
Approach
Straightforward translation to relational representation of program
(label insertion)
Labels roughly correspond with boundaries of shadows
Interesting part: how to translate the static pointcuts to sets of
labels?
Also: how do we know this translation is sound?
Center for Software Technology Sander Mak
40. Advice weaving in AspectJ > Semantics of static pointcuts
Datalog
Pointcuts are rewritten to Datalog:
A safe subset of Prolog (logic language based on facts and
relations)
Properties of Datalog:
Creation of datastructures not possible
Clear and straightforward semantics
More efficient than Prolog
Translation using term rewriting (Stratego)
Result of translated Datalog querie is the set of labels for pointcut
Center for Software Technology Sander Mak
41. Advice weaving in AspectJ > Semantics of static pointcuts
Executable specification
Datalog can be
interpreted...
.. by mapping to SQL!
So the queries can be
executed
Typically 4 times slower
than ajc
Gain: direct
correspondence
between semantics and
implementation
And: you could write
Datalog queries directly
Center for Software Technology Sander Mak
42. Advice weaving in AspectJ > Conclusion
Concluding remarks
The weaver of ajc is complex
Much can be gained using static analysis while weaving
Current version of AspectJ is already much improved
An alternative for ajc is abc, though it has different properties
A thorough description of pointcuts has been made outside of the
AspectJ project
Center for Software Technology Sander Mak
43. Advice weaving in AspectJ > Questions
Question: Wouter
What would be the reason they chose to compile both the plain Java
and the aspect first to bytecode and then weave it? Why not instead
weave the aspect source code (after translation to plain Java) directly
into the Java source code and then compile it.
Probable advantages:
This is easier to implement I think
This does not depend on (maybe changing) bytecode expressions
You can actually see what happens, this can be handy when
learning AspectJ
You will be able to see the actual produced code, this might not
be very nice code, but It could definitely help when debugging
With all the code available at the same time the Java compiler
might be able to do more optimizations
Center for Software Technology Sander Mak
44. Advice weaving in AspectJ > Questions
Question: Wouter
Other reasons pro:
’Even if you are generating perfectly legal bytecodes, straying too
far from the javac path can uncover bugs in VMs.’
If weaving source code, javac will save you from this
You can do more:
Begin and end of exception handler available
Source location reported more accurately
Center for Software Technology Sander Mak
45. Advice weaving in AspectJ > Questions
Question: Wouter
Other reasons pro:
’Even if you are generating perfectly legal bytecodes, straying too
far from the javac path can uncover bugs in VMs.’
If weaving source code, javac will save you from this
You can do more:
Begin and end of exception handler available
Source location reported more accurately
Reasons con:
Source is not always available
Temptation to change generated code is big
Not possible to do weaving at loadtime
Analysis (munging!) much easier (no need to replicate javac’s
name-resolution, type system etc.)
Center for Software Technology Sander Mak
46. Advice weaving in AspectJ > Questions
Question: Wouter
Other reasons pro:
’Even if you are generating perfectly legal bytecodes, straying too
far from the javac path can uncover bugs in VMs.’
If weaving source code, javac will save you from this
You can do more:
Begin and end of exception handler available
AspectJSource location reported more accurately
AspectJ moved from source weaving, in the early days, to bytecode
Reasons con:
weaving nowadays.
Source is not always available
Mostly due to to change generated code is big
Temptation the analysis argument.
In Not opinion, abcdo weaving theloadtime
my possible to has found at right middle ground
Analysis (munging!) much easier (no need to replicate javac’s
name-resolution, type system etc.)
Center for Software Technology Sander Mak
47. Advice weaving in AspectJ > Questions
Question: Elmar
The authors say that ’AspectJ’s implementations have used every form
of transformation imaginable for a Java program’. But they don’t
discuss the pro’s and con’s of the different transformation and why
AspectJ is now a bytecode transformer.
What do you think is the reason that AspectJ is now constructed as a
bytecode transformer as apposed to a Java transformer?
Center for Software Technology Sander Mak
48. Advice weaving in AspectJ > Questions
Question: Elmar
The authors say that ’AspectJ’s implementations have used every form
of transformation imaginable for a Java program’. But they don’t
discuss the pro’s and con’s of the different transformation and why
AspectJ is now a bytecode transformer.
What do you think is the reason that AspectJ is now constructed as a
bytecode transformer as apposed to a Java transformer?
As said: ease of analysis has been decisive factor
Performance might have been also (esp. with new FastMatch)
Center for Software Technology Sander Mak
49. Advice weaving in AspectJ > Questions
Question: Jinfeng
If a pointcut captures a good many calls in an advice, when the aspect
is woven into the application, the size of the class file increases many
times dramatically. In that case, running this application on your
server may incur an OutOfMemoryError. So do you have any
idea/experience to avoid/reduce this problem?
Center for Software Technology Sander Mak
50. Advice weaving in AspectJ > Questions
Question: Jinfeng
If a pointcut captures a good many calls in an advice, when the aspect
is woven into the application, the size of the class file increases many
times dramatically. In that case, running this application on your
server may incur an OutOfMemoryError. So do you have any
idea/experience to avoid/reduce this problem?
Not really a problem fundamental to AOP (handcoded would
result in comparable codebase)
Weaving in ajc results mostly in calls to advice
Modest overhead
Inlining would be more problematic
Center for Software Technology Sander Mak
51. Advice weaving in AspectJ > Questions
Question: Nabil
The paper mentions that adding a static test (‘static field enabled‘) to
the pointcut ‘traced‘ increases the performance of the code and makes
even faster than the hand-coded version. Could you explain how this is
possible? Because I would expect the performance to be same or
reduced when an extra test is added to the pointcut.
Center for Software Technology Sander Mak
52. Advice weaving in AspectJ > Questions
Question: Nabil
The paper mentions that adding a static test (‘static field enabled‘) to
the pointcut ‘traced‘ increases the performance of the code and makes
even faster than the hand-coded version. Could you explain how this is
possible? Because I would expect the performance to be same or
reduced when an extra test is added to the pointcut.
Corresponding pointcut/advice:
static boolean enabled;
pointcut traced() = execution(* *(..)) &&
if (enabled) && if (log.isLoggable(Level.FINER)) ;
before(): traced() {
Signature s = thisJoinPointStaticPart.getSignature();
log.entering(s.getDeclaringType().getName(),
s.getname());
} Center for Software Technology Sander Mak
53. Advice weaving in AspectJ > Questions
Question: Nabil
Hand-coded does not mean that static check of enabled is added.
Center for Software Technology Sander Mak
54. Advice weaving in AspectJ > Questions
Question: Nabil
Corresponding pointcut/advice:
pointcut traced() = execution(* *(..)) &&
if (enabled) && if (log.isLoggable(Level.FINER)) ;
&& is short-circuit (or lazy)
Static field lookup and boolean comparison: very cheap
Prevents call to isLoggable, that requires
Lookup of Level.FINER
Pushing it on the stack
Resolving log (push on the stack
invokevirtual method call (new stackframe created)
All in all, this is only faster because hand-coded code was not
adapted
Would have involved changing 7700 locations: hence we saw a
cross-cutting optimization!
Center for Software Technology Sander Mak
55. Advice weaving in AspectJ > Questions
Question: Niels
I tried to compile an aspect program and make an executable Jar, it
seems that it is possible to run the Jar without referencing the AspectJ
package, but you will get 1 exception over and over (probably when
using functions which use the aspect classes):
Exception in thread ... java.lang.NoClassDefFoundError:
org/aspectj/lang/NoAspectBoundException
The developers of AspectJ did a pretty good job on allowing you to
create programs without the need of the AspectJ library when you
distribute it, what could be the reason for them to depend on this 1
class?
Center for Software Technology Sander Mak
56. Advice weaving in AspectJ > Questions
Question: Niels
Actually, there are a lot more dependencies (depending on features
used):
AroundClosure and its machinery
CFlowStack for bookkeeping of cflow pointcuts
all types involved with thisJoinPoint
Center for Software Technology Sander Mak
57. Advice weaving in AspectJ > Questions
Question: Niels
Actually, there are a lot more dependencies (depending on features
used):
AroundClosure and its machinery
CFlowStack for bookkeeping of cflow pointcuts
all types involved with thisJoinPoint
Matt Chapman (AspectJ developer) on this matter:
Yes, aspects are woven into class files, but there will be references to
classes in the runtime library. This needs to be distributed with your
software. This is unavoidable, .... you need the very small
org.aspectj.runtime plugin.
Center for Software Technology Sander Mak
58. Advice weaving in AspectJ > Questions
Question: Niels
For your specific problem:
Exception in thread ... java.lang.NoClassDefFoundError:
org/aspectj/lang/NoAspectBoundException
... what could be the reason for them to depend on this 1 class?
We turn to the source:
NoAspectBoundException.java
/**
* Thrown by the aspectOf special method on aspect types
* when there is no aspect of that type currently bound.
*/
public class NoAspectBoundException extends
RuntimeException { .. }
Center for Software Technology Sander Mak
59. Advice weaving in AspectJ > Questions
Question: Niels
It looks like one of the previous problems (what is the ordering of
aspects, because it does matter) comes from the fact that the original
aspects aren’t preserved after compiling them (or aren’t used anymore):
Code
foo(new NonString());
pointcut fooOnString(String s) : call(* foo(s));
// Will not apply on the foo call, NonString is not a
subclass of String
Because, for now, this will never apply, this call won’t get a dynamic
check to see if NonString is a subclass of String.
Center for Software Technology Sander Mak
60. Advice weaving in AspectJ > Questions
Question: Niels
If you add an aspect later with this line:
declare parents NonString extends String
Now you might have needed the dynamic check, because now the first
pointcut should apply to the function.
Wouldn’t it be a good idea to keep the aspect, or remember where the
aspect could have applied to allow these changes to do what they are
supposed to (it might even be discussable if this is a change you would
want)
Center for Software Technology Sander Mak
61. Advice weaving in AspectJ > Questions
Question: Niels
If you add an aspect later with this line:
declare parents NonString extends String
Now you might have needed the dynamic check, because now the first
pointcut should apply to the function.
Wouldn’t it be a good idea to keep the aspect, or remember where the
aspect could have applied to allow these changes to do what they are
supposed to (it might even be discussable if this is a change you would
want)
As far as I could find out: inter-type aspects are applied before
others
Already in front-end of ajc, but I found little info
Not sure if this also works with load-time weaving
Center for Software Technology Sander Mak