OW2 Utilities is a newly accepted project in the consortium. It aims to be the OW2 toolkit catalog for common pieces of code that everybody rewrite for each new project. This presentation will start with a description of the goals of that project, a little bit of history, then we will explain why it's important to maximize re-use within the consortium (reliability, ...). In a second part we will focus to the most useful and/or interesting modules provided by this project. This session will be developer-oriented, with code samples and effective use cases.
This document provides an overview of tools available in the Java Development Kit (JDK) that allow for powerful introspection and manipulation of the Java Virtual Machine (JVM) and running applications. It discusses the java.lang.instrument API for injecting Java agents, the Java Debugging Interface (JDI) for debugging, the JVM Tool Interface (JVMTI) for heap and frame introspection, and examples of using these tools to build interactive debuggers, inject code at runtime, and test concurrency. Code samples and links to further resources are also provided.
Mastering Java Bytecode With ASM - 33rd degree, 2012Anton Arhipov
The document discusses bytecode and the ASM library for manipulating Java bytecode. It provides an overview of bytecode structure and instructions. ASM is introduced as a low-level API for working with bytecode using visitors and nodes. Examples are given for generating bytecode using ASM, such as creating a ClassWriter, visiting classes, fields and methods, and generating instructions.
The document introduces a plan to cover Java and Android basics, Android UI topics, and Android in action over three parts. Part I provides an introduction to Java concepts like the JVM, garbage collection, threads, and an overview of the Android architecture and building blocks. It also demonstrates an NDK example. The document outlines the topics that will be covered in each part of the training.
The document discusses the evolution of the Java platform, including new features in Java SE 7 and Java SE 8. Some key changes in Java SE 7 include better integer literals, string switches, simplified generics using diamond operator, and automatic resource management. Java SE 8 will focus on invokedynamic for multi-language support on the JVM and method handles. The JVM specification defines the runtime environment independently of the Java programming language.
This document provides an overview of ActionScript, including:
- It is an object-oriented programming language that supports encapsulation, abstraction, inheritance, and polymorphism.
- ActionScript code is defined in files with a .as extension or embedded in MXML files.
- It has basic data types like int, Number, Boolean, String, and others.
- Classes must define a public constructor.
- Functions are defined with access modifiers, arguments, return types.
- Events and event handling are used for user interactions.
- Runtime type checking uses the "is" operator and casting uses "as".
- Exceptions use try/catch/finally blocks.
Making Java more dynamic: runtime code generation for the JVMRafael Winterhalter
While Java’s strict type system is a great help for avoiding programming errors, it also takes away some of the flexibility that developers appreciate when using dynamic languages. By using runtime code generation, it is possible to bring some of this flexibility back to the Java virtual machine. For this reason, runtime code generation is widely used by many state-of-the-art Java frameworks for implementing POJO-centric APIs but it also opens the door to assembling more modular applications. This presentation offers an introduction to the complex of runtime code generation and its use on the Java platform. Furthermore, it discusses the up- and downsides of several code generation libraries such as ASM, Javassist, cglib and Byte Buddy.
Annotation processing allows for metadata to be added to Java programs without altering the program itself. Annotations can be defined and used to provide information for compilers or allow runtime/compile-time processing. Annotation processors provide a hook into the Java compilation process to generate source code and compile errors/warnings. They work by processing annotated elements in rounds. Testing annotation processors is challenging but libraries like Google's compile-testing library can help. Annotation processing also works on Android by setting up the processor as a Java module and using plugins like android-apt.
This document discusses building a Java tracer using bytecode, JNI, JVMTI and ASM. It covers Java bytecode format, using JNI and JVMTI to build C extensions that interface with the JVM, ASM for bytecode analysis and manipulation, and a demo of using these technologies to trace a "Hello, World" program. It also outlines areas for further work on the tracer and takes questions.
This document provides an overview of tools available in the Java Development Kit (JDK) that allow for powerful introspection and manipulation of the Java Virtual Machine (JVM) and running applications. It discusses the java.lang.instrument API for injecting Java agents, the Java Debugging Interface (JDI) for debugging, the JVM Tool Interface (JVMTI) for heap and frame introspection, and examples of using these tools to build interactive debuggers, inject code at runtime, and test concurrency. Code samples and links to further resources are also provided.
Mastering Java Bytecode With ASM - 33rd degree, 2012Anton Arhipov
The document discusses bytecode and the ASM library for manipulating Java bytecode. It provides an overview of bytecode structure and instructions. ASM is introduced as a low-level API for working with bytecode using visitors and nodes. Examples are given for generating bytecode using ASM, such as creating a ClassWriter, visiting classes, fields and methods, and generating instructions.
The document introduces a plan to cover Java and Android basics, Android UI topics, and Android in action over three parts. Part I provides an introduction to Java concepts like the JVM, garbage collection, threads, and an overview of the Android architecture and building blocks. It also demonstrates an NDK example. The document outlines the topics that will be covered in each part of the training.
The document discusses the evolution of the Java platform, including new features in Java SE 7 and Java SE 8. Some key changes in Java SE 7 include better integer literals, string switches, simplified generics using diamond operator, and automatic resource management. Java SE 8 will focus on invokedynamic for multi-language support on the JVM and method handles. The JVM specification defines the runtime environment independently of the Java programming language.
This document provides an overview of ActionScript, including:
- It is an object-oriented programming language that supports encapsulation, abstraction, inheritance, and polymorphism.
- ActionScript code is defined in files with a .as extension or embedded in MXML files.
- It has basic data types like int, Number, Boolean, String, and others.
- Classes must define a public constructor.
- Functions are defined with access modifiers, arguments, return types.
- Events and event handling are used for user interactions.
- Runtime type checking uses the "is" operator and casting uses "as".
- Exceptions use try/catch/finally blocks.
Making Java more dynamic: runtime code generation for the JVMRafael Winterhalter
While Java’s strict type system is a great help for avoiding programming errors, it also takes away some of the flexibility that developers appreciate when using dynamic languages. By using runtime code generation, it is possible to bring some of this flexibility back to the Java virtual machine. For this reason, runtime code generation is widely used by many state-of-the-art Java frameworks for implementing POJO-centric APIs but it also opens the door to assembling more modular applications. This presentation offers an introduction to the complex of runtime code generation and its use on the Java platform. Furthermore, it discusses the up- and downsides of several code generation libraries such as ASM, Javassist, cglib and Byte Buddy.
Annotation processing allows for metadata to be added to Java programs without altering the program itself. Annotations can be defined and used to provide information for compilers or allow runtime/compile-time processing. Annotation processors provide a hook into the Java compilation process to generate source code and compile errors/warnings. They work by processing annotated elements in rounds. Testing annotation processors is challenging but libraries like Google's compile-testing library can help. Annotation processing also works on Android by setting up the processor as a Java module and using plugins like android-apt.
This document discusses building a Java tracer using bytecode, JNI, JVMTI and ASM. It covers Java bytecode format, using JNI and JVMTI to build C extensions that interface with the JVM, ASM for bytecode analysis and manipulation, and a demo of using these technologies to trace a "Hello, World" program. It also outlines areas for further work on the tracer and takes questions.
An overview how to realize code generation of languages on the JVM that implement other class layouts than the Java programming languages. As an example, the inline-mock-maker for Mockito is discussed which supports languages like Kotlin that make any property final by default.
Java Annotation is quite a handy tool and has the ample potential to make developer's life a lot easier(and exciting!). Learning and using custom Java Annotation Processor takes the power of Annotation even a class higher. This slide goes over a few fundamental things of an Annotation Processor to get someone started to write his/her own Annotation Processor in Java.
Key topics are,
- Java Annotation
- Usage of Annotation
- Custom Java Annotation
- Java Annotation Processor
- Usefulness of Annotation Processor
- Dive into the core of Annotation Processor
- Solve a validation problem with Custom Annotation Processor
- Get to know some exciting Annotation Processing tools that already exist
1. Garbage collection is a technique for automatically reclaiming heap memory that is no longer reachable by the running program. This avoids issues with explicit deallocation like memory leaks and use-after-free bugs.
2. Early techniques included reference counting and mark-and-sweep garbage collection. Reference counting has issues with cyclic data structures. Mark-and-sweep involves tracing reachable objects from program roots and freeing unreachable objects.
3. Modern garbage collectors use generational collection, where newer objects are more likely to die young and are collected more frequently in a nursery space via copying collection. Older objects in a tenured space are collected less often with mark-sweep.
OWASP SD: Deserialize My Shorts: Or How I Learned To Start Worrying and Hate ...Christopher Frohoff
Object deserialization is an established but poorly understood attack vector in applications that is disturbingly prevalent across many languages, platforms, formats, and libraries.
In January 2015 at AppSec California, Chris Frohoff and Gabe Lawrence gave a talk on this topic, covering deserialization vulnerabilities across platforms, the many forms they take, and places they can be found. It covered, among other things, somewhat novel techniques using classes in commonly used libraries for attacking Java serialization that were subsequently released in the form of the ysoserial tool. Few people noticed until late 2015, when other researchers used these techniques/tools to exploit well known products such as Bamboo, WebLogic, WebSphere, ApacheMQ, and Jenkins, and then services such as PayPal. Since then, the topic has gotten some long-overdue attention and great work is being done by many to improve our understanding and developer awareness on the subject.
This talk will review the details of Java deserialization exploit techniques and mitigations, as well as report on some of the recent (and future) activity in this area.
http://www.meetup.com/Open-Web-Application-Security-Project-San-Diego-OWASP-SD/events/226242635/
This presentation is based on Joakim\’s experiences from moving from Java to Scala http://www.scala-lang.org/node/960#Joak We will explore how to move from Java to Scala and why. We\’ll look at things that you will run into sooner rather than later such as Scala\’s collection APIs, Options and higher order functions and special syntax. You will leave this presentation with good foundation to use Scala in practice; perhaps even in your current Java project and ideally with an appetite to learn more.
This document discusses invokedynamic and the JSR-292 API. It provides an overview of invokedynamic, how it is used in the JVM to support multiple languages, and how it works with MethodHandles and CallSites. It also summarizes the key classes and methods in the JSR-292 API, including MethodHandles, MethodHandles.Lookup, MethodType, and how they can be used to dynamically call methods via MethodHandles.
With its ninth version, the Java platform has shifted gear and introduced biyearly releases. This was followed by a license change where Oracle, the steward of Java, now publishes a commercial and a non-commercial release of the Java virtual machine while other vendors took more space to promote their alternative builds of the OpenJDK. And in another flood of news, the Java EE specification was terminated and resolved into the Jakarta EE namespace.
A lot has been happening in the traditionally conservative Java ecosystem, to say the least, and many users are wondering if they still can rely on the platform. This talk gives an overview of the Java ecosystem, summarizes the changes that have been, that to expect and why the evolution of the platform is good news to the community.
Java 9 introduces modules to the Java programming language and its runtime. Despite this feature being optional, due to the modularization of the standard library existing applications might behave differently when running on a version 9 JVM. Furthermore, because of changes in the runtime, existing libraries and frameworks might not yet correctly process your modularized code. As a result, updating to a Java 9 VM and taking Java 9 into brings its challanges.
This talk discusses the practical implications of module boundaries and analyzes new limitations Java 9 imposes on the reflection API. This talk explains how reflection is used in popular frameworks like Spring and Hibernate and explains why existing applications might break or change their behavior when facing modularized code. Finally, this talk showcases alternatives to now failing Java programming patterns and weights their robustness with regard to the Java releases 10 and upward.
The presenter is an active contributor to open source and helped to migrate many popular Java libraries to supporting Java 9. As a consequence, he as been working with Java 9 for almost two years.
This document provides an overview of developing applications for the iPhone using Objective-C and the UIKit framework. It discusses Objective-C concepts like classes, memory management, categories and protocols. It also covers the iPhone UIKit including views, navigation controllers, tab bar controllers and table views. Other topics include data storage options like property lists, SQLite and web services. Sample code is provided to demonstrate various Objective-C and iPhone programming concepts.
This document summarizes new features in Java 7, including underscores in numeric literals to improve readability, try-with-resource for automatic resource management, multi-catch exceptions, and various improvements to I/O, generics, and garbage collection. Key areas covered are numeric literals, collection initialization, try-with-resource blocks, multi-catch exceptions, final rethrow, strings in switch statements, generic instances, NIO2 file APIs, file change notifications, asynchronous I/O, URLClassLoader closing, JDBC row sets, varargs, the G1 garbage collector, and improved performance.
The document discusses leveraging OSGi in Java EE business applications using JOnAS. It describes how OSGi can help build modular applications and introduces the benefits of a service-oriented approach. It also explains how hybrid applications can use the best of OSGi and Java EE, and how JOnAS is built on OSGi to provide Java EE services through an OSGi framework. This allows Java EE components and OSGi bundles to access each other's services.
The document discusses OSGi, an open-services ecosystem being developed to enable different devices and software to work together seamlessly. It outlines the objectives of OSGi including designing an adaptable global platform to maximize interoperability. It then provides an overview of the technologies being used like OSGi, OW2 μJOnAS, and Apache Felix. It zooms in on the French consortium's use case involving integrating heterogeneous sensors and actuators for energy efficiency in smart homes and buildings. A common demonstrator is proposed to showcase the components' interoperability in a smart home scenario.
The document outlines a collaboration between Peking University, Bull SAS, and CVIC SE to enhance the open source JOnAS application server. Peking University and Bull SAS will contribute improvements to the OW2 JOnAS project. The collaboration aims to develop business through joint projects utilizing JOnAS and to promote the technology in China and Europe.
The document describes the Peergreen Platform. It provides an overview of Peergreen as a startup with experienced engineers and open source contributions. It then discusses in depth the guidelines, boot process, deployment system, shell, web integration, console, security features, and development tools of the Peergreen Platform. Finally, it outlines next steps such as adding Java Transaction and Persistence API support.
Windows Azure est une plateforme IaaS qui n'est pas réservée exclusivement aux application .NET. Cette session explore et explique comment déployer le serveur d'application JOnAS sur le cloud de Microsoft
This talk focus on the Peergreen Deployment System and how we leverage the recent OSGi Resolver specification to build an efficient and extensible OSGi deployment framework.
OW2 Utilities is a project that provides reusable components and libraries for OW2 projects. It started in 2006 and contains modules for logging, XML parsing, internationalization, and more. The modules are packaged as OSGi bundles to make them easily reusable. The project is actively developed on GitHub and uses Bamboo for continuous integration.
An overview how to realize code generation of languages on the JVM that implement other class layouts than the Java programming languages. As an example, the inline-mock-maker for Mockito is discussed which supports languages like Kotlin that make any property final by default.
Java Annotation is quite a handy tool and has the ample potential to make developer's life a lot easier(and exciting!). Learning and using custom Java Annotation Processor takes the power of Annotation even a class higher. This slide goes over a few fundamental things of an Annotation Processor to get someone started to write his/her own Annotation Processor in Java.
Key topics are,
- Java Annotation
- Usage of Annotation
- Custom Java Annotation
- Java Annotation Processor
- Usefulness of Annotation Processor
- Dive into the core of Annotation Processor
- Solve a validation problem with Custom Annotation Processor
- Get to know some exciting Annotation Processing tools that already exist
1. Garbage collection is a technique for automatically reclaiming heap memory that is no longer reachable by the running program. This avoids issues with explicit deallocation like memory leaks and use-after-free bugs.
2. Early techniques included reference counting and mark-and-sweep garbage collection. Reference counting has issues with cyclic data structures. Mark-and-sweep involves tracing reachable objects from program roots and freeing unreachable objects.
3. Modern garbage collectors use generational collection, where newer objects are more likely to die young and are collected more frequently in a nursery space via copying collection. Older objects in a tenured space are collected less often with mark-sweep.
OWASP SD: Deserialize My Shorts: Or How I Learned To Start Worrying and Hate ...Christopher Frohoff
Object deserialization is an established but poorly understood attack vector in applications that is disturbingly prevalent across many languages, platforms, formats, and libraries.
In January 2015 at AppSec California, Chris Frohoff and Gabe Lawrence gave a talk on this topic, covering deserialization vulnerabilities across platforms, the many forms they take, and places they can be found. It covered, among other things, somewhat novel techniques using classes in commonly used libraries for attacking Java serialization that were subsequently released in the form of the ysoserial tool. Few people noticed until late 2015, when other researchers used these techniques/tools to exploit well known products such as Bamboo, WebLogic, WebSphere, ApacheMQ, and Jenkins, and then services such as PayPal. Since then, the topic has gotten some long-overdue attention and great work is being done by many to improve our understanding and developer awareness on the subject.
This talk will review the details of Java deserialization exploit techniques and mitigations, as well as report on some of the recent (and future) activity in this area.
http://www.meetup.com/Open-Web-Application-Security-Project-San-Diego-OWASP-SD/events/226242635/
This presentation is based on Joakim\’s experiences from moving from Java to Scala http://www.scala-lang.org/node/960#Joak We will explore how to move from Java to Scala and why. We\’ll look at things that you will run into sooner rather than later such as Scala\’s collection APIs, Options and higher order functions and special syntax. You will leave this presentation with good foundation to use Scala in practice; perhaps even in your current Java project and ideally with an appetite to learn more.
This document discusses invokedynamic and the JSR-292 API. It provides an overview of invokedynamic, how it is used in the JVM to support multiple languages, and how it works with MethodHandles and CallSites. It also summarizes the key classes and methods in the JSR-292 API, including MethodHandles, MethodHandles.Lookup, MethodType, and how they can be used to dynamically call methods via MethodHandles.
With its ninth version, the Java platform has shifted gear and introduced biyearly releases. This was followed by a license change where Oracle, the steward of Java, now publishes a commercial and a non-commercial release of the Java virtual machine while other vendors took more space to promote their alternative builds of the OpenJDK. And in another flood of news, the Java EE specification was terminated and resolved into the Jakarta EE namespace.
A lot has been happening in the traditionally conservative Java ecosystem, to say the least, and many users are wondering if they still can rely on the platform. This talk gives an overview of the Java ecosystem, summarizes the changes that have been, that to expect and why the evolution of the platform is good news to the community.
Java 9 introduces modules to the Java programming language and its runtime. Despite this feature being optional, due to the modularization of the standard library existing applications might behave differently when running on a version 9 JVM. Furthermore, because of changes in the runtime, existing libraries and frameworks might not yet correctly process your modularized code. As a result, updating to a Java 9 VM and taking Java 9 into brings its challanges.
This talk discusses the practical implications of module boundaries and analyzes new limitations Java 9 imposes on the reflection API. This talk explains how reflection is used in popular frameworks like Spring and Hibernate and explains why existing applications might break or change their behavior when facing modularized code. Finally, this talk showcases alternatives to now failing Java programming patterns and weights their robustness with regard to the Java releases 10 and upward.
The presenter is an active contributor to open source and helped to migrate many popular Java libraries to supporting Java 9. As a consequence, he as been working with Java 9 for almost two years.
This document provides an overview of developing applications for the iPhone using Objective-C and the UIKit framework. It discusses Objective-C concepts like classes, memory management, categories and protocols. It also covers the iPhone UIKit including views, navigation controllers, tab bar controllers and table views. Other topics include data storage options like property lists, SQLite and web services. Sample code is provided to demonstrate various Objective-C and iPhone programming concepts.
This document summarizes new features in Java 7, including underscores in numeric literals to improve readability, try-with-resource for automatic resource management, multi-catch exceptions, and various improvements to I/O, generics, and garbage collection. Key areas covered are numeric literals, collection initialization, try-with-resource blocks, multi-catch exceptions, final rethrow, strings in switch statements, generic instances, NIO2 file APIs, file change notifications, asynchronous I/O, URLClassLoader closing, JDBC row sets, varargs, the G1 garbage collector, and improved performance.
The document discusses leveraging OSGi in Java EE business applications using JOnAS. It describes how OSGi can help build modular applications and introduces the benefits of a service-oriented approach. It also explains how hybrid applications can use the best of OSGi and Java EE, and how JOnAS is built on OSGi to provide Java EE services through an OSGi framework. This allows Java EE components and OSGi bundles to access each other's services.
The document discusses OSGi, an open-services ecosystem being developed to enable different devices and software to work together seamlessly. It outlines the objectives of OSGi including designing an adaptable global platform to maximize interoperability. It then provides an overview of the technologies being used like OSGi, OW2 μJOnAS, and Apache Felix. It zooms in on the French consortium's use case involving integrating heterogeneous sensors and actuators for energy efficiency in smart homes and buildings. A common demonstrator is proposed to showcase the components' interoperability in a smart home scenario.
The document outlines a collaboration between Peking University, Bull SAS, and CVIC SE to enhance the open source JOnAS application server. Peking University and Bull SAS will contribute improvements to the OW2 JOnAS project. The collaboration aims to develop business through joint projects utilizing JOnAS and to promote the technology in China and Europe.
The document describes the Peergreen Platform. It provides an overview of Peergreen as a startup with experienced engineers and open source contributions. It then discusses in depth the guidelines, boot process, deployment system, shell, web integration, console, security features, and development tools of the Peergreen Platform. Finally, it outlines next steps such as adding Java Transaction and Persistence API support.
Windows Azure est une plateforme IaaS qui n'est pas réservée exclusivement aux application .NET. Cette session explore et explique comment déployer le serveur d'application JOnAS sur le cloud de Microsoft
This talk focus on the Peergreen Deployment System and how we leverage the recent OSGi Resolver specification to build an efficient and extensible OSGi deployment framework.
OW2 Utilities is a project that provides reusable components and libraries for OW2 projects. It started in 2006 and contains modules for logging, XML parsing, internationalization, and more. The modules are packaged as OSGi bundles to make them easily reusable. The project is actively developed on GitHub and uses Bamboo for continuous integration.
JavaOne 2014 - CON2013 - Code Generation in the Java Compiler: Annotation Pro...Jorge Hidalgo
Slides from JavaOne 2014 conference session CON2013
The Java compiler and annotation processors are powerful tools within the Java platform, and both, combined, unleash great power in developers’ hands, as this session illustrates. Triggered during the Java compilation process, APs can be used to generate new sources and configuration from metadata present in the class source. Why expend time creating a BeanInfo class or dealing with boring XML configuration files when you can have them easily created at compilation time? Moreover, APs are compatible with IDEs and build tools, and hence they are virtually everywhere your Java code is. Unleash the power of annotation processors, and let them do the hard work for you
A beginner's guide to annotation processing.
In this talk that I gave at Droidcon Tel Aviv in 2016, I walk you through the process of building a custom annotation processor which mimics some of the behavior you may be familiar with from the popular Android library: Butter Knife.
Write code that writes code! A beginner's guide to Annotation Processing - Ja...DroidConTLV
This document provides a summary of creating a custom annotation processor called "Soup Ladle" that allows for view binding in Android with the @Bind annotation. It discusses defining the @Bind annotation, extending the AbstractProcessor class to process the annotation, scanning code for @Bind fields and their parent classes, and generating SoupLadle.java files with binding methods for each parent class. The goal is to allow easy one-line view binding like SoupLadle.bind(this) for learning purposes and as a simpler alternative to libraries like ButterKnife.
The document discusses annotation processing tools (APT). It begins by defining what an annotation is and how they are used. It then covers retention policies, how annotations can be accessed at runtime via reflection, and the Mirror API. The bulk of the document provides an example of creating a custom annotation processor for Android data binding. It demonstrates creating annotations, configuring a processor, processing annotation elements, and generating code. The key aspects covered are how to implement an annotation processor by extending AbstractProcessor and processing annotation elements in the RoundEnvironment.
This document discusses aspect oriented programming (AOP) with Spring. It describes how AOP can be used to modularize cross-cutting concerns like logging and transaction management. It provides examples of implementing logging using both a naive approach and with AOP. It explains key AOP concepts like aspects, pointcuts, join points and advice. It also summarizes how AOP can be used with Spring through either the @AspectJ annotation style or XML schema-based style.
- Lithium is an upcoming PHP framework that is lightweight and flexible
- It uses MongoDB as its primary database and supports MySQL as well
- The presentation covered the core functionality of Lithium including installation, models, controllers, views and provided examples of using it to build a blog application
This document provides an overview of SAX and DOM, which are APIs for parsing XML documents. It discusses:
- SAX and DOM are standards for XML parsers that allow reading and interpreting XML files. SAX is event-based and reads XML sequentially, while DOM loads the entire XML document into memory allowing random access.
- SAX works through callbacks, where the parser calls methods supplied by the application to handle events like start elements, end elements, and character data.
- A simple SAX program is demonstrated using two classes - one contains the main method and parses the XML, while the other implements handler callbacks.
- Key differences between SAX and DOM are that DOM provides random access to
Here are the key points about classes and metaclasses in Objective-C:
- Every Objective-C class is an instance of another class called its metaclass. The metaclass allows the class to receive and respond to messages.
- The root class is called Class. All other classes are subclasses of Class.
- When you send a message to a class like [MyClass foo], it is actually sending the message to the metaclass of MyClass, not to MyClass itself. The metaclass handles class methods and behaviors.
- The isa pointer in the class structure points to the metaclass, not the superclass. This allows classes to behave like objects and receive messages.
- So in summary, classes are objects (instances
Practical Chaos Engineering will show how to start running chaos experiments in your infrastructure and will try to guide your through the principles of chaos.
Workshop slides originally given at the WOPR Summit in Atlantic City. Use JavaScript parsers and generators like Shift combined with Puppeteer and Chrome to reverse engineer web applications
Spoon is an open-source library that enables you to transform and analyze Java source code. Due to a complete and fine-grained Java metamodel, you can read and write the AST built by Spoon. In this talk, you'll see all strong concepts and API with an example. Then, you'll see how you can integrate this project in yours.
Java programs run on the Java Virtual Machine (JVM). The JVM provides a runtime environment that executes Java bytecode. Key aspects of Java include its use of object-oriented programming, garbage collection, and strong typing. Popular integrated development environments for Java include Eclipse and IntelliJ IDEA.
Presented at BJUG, 6/12/2012 by Roger Brinkley
This talk is on 55 new features in Java 7 you (probably) didn't hear about in an ignite format of one per minute. No stopping, no going back....Questions, sure but only if time remains (otherwise save for later).
The document provides an overview of Java collections and exceptions. It discusses core collection interfaces like Collection, Set, List, Queue, and Map. It also covers exception handling in Java and common exception classes. The document contains examples and tips for using collections and exceptions in code. Key collection implementations like ArrayList, HashSet, and HashMap are described.
Postdoc symposium - A Logic Meta-Programming Foundation for Example-Driven Pa...ICSM 2011
Paper: A Logic Meta-Programming Foundation for Example-Driven Pattern Detection in Object-Oriented Programs
Author: Coen De Roover
Session: Post-doctoral symposium
A Logic Meta-Programming Foundation for Example-Driven Pattern Detection in O...Coen De Roover
Presentation at the Postdoctoral symposium of the 2011 International Conference on Software Maintenance, accompanying the paper
http://soft.vub.ac.be/Publications/2011/vub-soft-tr-11-11.pdf
The document provides an overview and introduction to TuProlog (2P), a Java-based Prolog system for pervasive intelligence. 2P allows Prolog programs to be integrated with Java applications and provides tools and libraries to extend its functionality. The key points covered include: 2P's design goals of minimality and bidirectional Java integration; how to use 2P from Java via its API; how to extend 2P by developing custom libraries; and examples of using the JavaLibrary to access Java classes and methods from Prolog.
Similar to Ow2 Utilities - The Swiss Army Knife Of Ow2 Projects (20)
La thématique de protection des données personnelles prend de plus en plus d'importance tandis que nos vies réelles et nos vies numériques se confondent.
Les gouvernements commencent à prendre cette préoccupation au sérieux et des lois contraignant les acteurs du numérique émergent:
* Droit à l'oubli
* Information sur les cookies
* GDPR en Europe
On le voit bien, ces lois ont des implications techniques.
On verra quelles sont les techniques utilisées actuellement pour répondre à ces contraintes, les standards émergeants (UMA 2), ...
En un mot, comment redonner le contrôle aux utilisateurs sur leurs données.
OAuth 2.0 est un standard d'autorisation moderne (comprendre avec du JSON partout) qui permet de controller l'accès aux resources web. Cette présentation vous apprendra les pas de danse OAuth 2.0, et vous initiera à la chorégraphie OpenId Connect. On parlera aussi des nouveautés: UMA, PoP, Privacy, Consent et autres acronymes barbares.
JOnAS application server uses profiles and micro profiles to allow for lightweight and customizable configurations based on specific needs, resources can be added or removed dynamically via deployment plans and profiles can be updated without rebooting through OSGi modularity. μJOnAS provides a minimal profile that serves as the basis for building customized profiles by adding additional services and components as needed via deployment plans.
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.
How to Interpret Trends in the Kalyan Rajdhani Mix Chart.pdfChart Kalyan
A Mix Chart displays historical data of numbers in a graphical or tabular form. The Kalyan Rajdhani Mix Chart specifically shows the results of a sequence of numbers over different periods.
Best 20 SEO Techniques To Improve Website Visibility In SERPPixlogix Infotech
Boost your website's visibility with proven SEO techniques! Our latest blog dives into essential strategies to enhance your online presence, increase traffic, and rank higher on search engines. From keyword optimization to quality content creation, learn how to make your site stand out in the crowded digital landscape. Discover actionable tips and expert insights to elevate your SEO game.
Digital Marketing Trends in 2024 | Guide for Staying AheadWask
https://www.wask.co/ebooks/digital-marketing-trends-in-2024
Feeling lost in the digital marketing whirlwind of 2024? Technology is changing, consumer habits are evolving, and staying ahead of the curve feels like a never-ending pursuit. This e-book is your compass. Dive into actionable insights to handle the complexities of modern marketing. From hyper-personalization to the power of user-generated content, learn how to build long-term relationships with your audience and unlock the secrets to success in the ever-shifting digital landscape.
GraphRAG for Life Science to increase LLM accuracyTomaz Bratanic
GraphRAG for life science domain, where you retriever information from biomedical knowledge graphs using LLMs to increase the accuracy and performance of generated answers
Webinar: Designing a schema for a Data WarehouseFederico Razzoli
Are you new to data warehouses (DWH)? Do you need to check whether your data warehouse follows the best practices for a good design? In both cases, this webinar is for you.
A data warehouse is a central relational database that contains all measurements about a business or an organisation. This data comes from a variety of heterogeneous data sources, which includes databases of any type that back the applications used by the company, data files exported by some applications, or APIs provided by internal or external services.
But designing a data warehouse correctly is a hard task, which requires gathering information about the business processes that need to be analysed in the first place. These processes must be translated into so-called star schemas, which means, denormalised databases where each table represents a dimension or facts.
We will discuss these topics:
- How to gather information about a business;
- Understanding dictionaries and how to identify business entities;
- Dimensions and facts;
- Setting a table granularity;
- Types of facts;
- Types of dimensions;
- Snowflakes and how to avoid them;
- Expanding existing dimensions and facts.
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
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
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.
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.
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.
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 .
24. A LITTLE BIT OF HISTORY
• Was born in 2006 inside the OW2 EasyBeans project
• Used in JOnAS, CAROL, CMI, EasyBeans, Shelbie, JASMINe for years
• Extracted as a separate maven project in 2008
• More than 35 releases up to today !
• Proposed as top level OW2 project in 2012
• We’re here now :)
OW2 Annual Conference 2012, 27-29 November, Orange Labs, Paris
www.ow2.org 4
53. code
EventDispatcher dispatcher = new EventDispatcher();
dispatcher.setNbWorkers(3); // Listen to all Event published in /result/**
dispatcher.start(); eventService.registerListener(listener, /result/.*);
// Topic registration
eventService.registerDispatcher(/result/success, dispatcher);
Dispatchers Loose Coupling Event Listeners
Event Source(s)
Asynchronous
Consumer(s)
/a/b
/a
/c
Event Service
// Dispatch an Event
dispatcher.dispatch(new MyEvent(/result/.*));
OW2 Annual Conference 2012, 27-29 November, Orange Labs, Paris
www.ow2.org 9
54. Re-using
POOL instances
public static void main(String[] args) throws Exception {
• Simple Pooling API
PoolFactoryPooled, Long poolFactory = new PooledFactory();
JPoolPooled,Long pool = new JPoolPooled, Long(poolFactory);
pool.start();
Pooled one = pool.get();
• Pool size, waiters, timeout
Pooled two = pool.get();
Pooled three = pool.get();
Pooled four = pool.get(); // Will block until timeout or a release
}
•
Thread-safe private static final class PooledFactory implements PoolFactoryPooled, Long {
public Pooled create(Long clue) throws PoolException {
return new Pooled(clue);
}
• Basic implementation
public boolean isMatching(Pooled instance, Long clue) {
}
return instance.id == clue;
public void remove(Pooled instance) { // Destroy instance }
•
public boolean validate(Pooled instance, PoolEntryStatistics stats) {
Synchronous
}
return true;
}
• Advanced implementation @Pool(min = 1, max = 3)
private static class Pooled {
long id;
public Pooled(Long clue) { id = clue; }
•
}
Asynchronous, composable
OW2 Annual Conference 2012, 27-29 November, Orange Labs, Paris
www.ow2.org 10
55. Variable
SUBSTITUTION processing
• Extract variables declaration from String
• ‘Hello ${speaker.name} !’ DefaultSubstitutionEngine engine = new DefaultSubstitutionEngine();
ChainedResolver chain = new ChainedResolver();
chain.getResolvers().add(new SpeakerResolver());
• PropertyResolvers
chain.getResolvers().add(new DateResolver());engine.setResolver(chain);
engine.substitute(Hello ${speaker.name} ! -- ${date});
public class SpeakerResolver implements IPropertyResolver {
public String resolve(String expression) {
return speaker.name.equals(expression) ? Guillaume : null;
• Provides value for expression
}
}
public class DateResolver implements IPropertyResolver {
public String resolve(String expression) {
• Composable
}
}
return date.equals(expression) ? (new Date()).toString() : null;
• Support recursion (variables in variable)
OW2 Annual Conference 2012, 27-29 November, Orange Labs, Paris
www.ow2.org 11
56. Resource
ARCHIVE Abstraction
• Uniform API for resource consumption
• Supporting (out of the box) public interface IArchive {
String getName();
URL getURL() throws ArchiveException;
• Directory URL getResource(String resourceName) throws ArchiveException;
IteratorURL getResources() throws ArchiveException;
• Jar IteratorURL getResources(String resourceName) throws ArchiveException;
IteratorString getEntries() throws ArchiveException;
boolean close();
• OSGi Bundle IArchiveMetadata getMetadata();
}
• Extensible
OW2 Annual Conference 2012, 27-29 November, Orange Labs, Paris
www.ow2.org 12
57. BUNDLES, BUNDLES, BUNDLES
• Around 20 common libraries wrapped as Bundles
• commons-{collections, logging, modeler}, javassist, jaxb2-ri, jgroups, jsch, opencsv,
weld, zookeeper, bouncycastle, ...
• Correct exported packages version, verified imports
• All other modules are OSGi Bundles
• Versioned API, content exported
OW2 Annual Conference 2012, 27-29 November, Orange Labs, Paris
www.ow2.org 13