Slides of Java One 2015 session "Advanced CDI in live coding"
In this session we explained how portable extensions work and shown third party framework integration with Metrics and Camel integration into CDI programming model
New features coming in CDI 2.0, talk given during Java One 2016
- Java SE support
- Async events
- Ordered events
- Meta data configurators
- Interceptors on producers
With less than five years and three releases under its belt, CDI has proven itself to be a great asset for Java. The many features it provides (dependency injection, contextual lifecycle, configuration, interception, event notification, and more) and the innovative way it provides them (through the use of meta-annotations) explain its rapid adoption. This session reviews the features introduced in CDI 1.1 and 1.2 and discusses improvements planned for CDI 2, such as standard support for Java SE and a light CDI version useful for embedded environments, showing how it will benefit Java.
Slides of the talk gave to Devoxx with José Paumard about new features coming in CDI 2. Java SE support, asynchronous event, Interceptor on producers...
Slides of the Java One 2015 talk "Apache DeltaSpike - the CDI Toolbox". It contains presentation of Apache DeltaSpike, the framework that extends CDI in Java or Java EE
Slides of the university I gave at Devoxx Belgium with Antonio Goncalves on CDI, Java EE and JBoss Forge.
Abstract:
-------
During this 3 hours university, you will learn some CDI basis, and will quickly dive into more advance CDI features (such as extension). Using JBoss Forge we will quickly generate a Java EE 7 web application, and then, following business requirements, we will add CDI functionalities.
This university talk will be a mixture of code and slides, focusing on CDI and Java EE 7.
--------
Video of the university is available on YouTube: http://youtu.be/LYKMaj4XKvg
Code and Slides on GitHub: https://github.com/antoinesd/cdi-forge-uni/tree/DevoxxBe2015
New features coming in CDI 2.0, talk given during Java One 2016
- Java SE support
- Async events
- Ordered events
- Meta data configurators
- Interceptors on producers
With less than five years and three releases under its belt, CDI has proven itself to be a great asset for Java. The many features it provides (dependency injection, contextual lifecycle, configuration, interception, event notification, and more) and the innovative way it provides them (through the use of meta-annotations) explain its rapid adoption. This session reviews the features introduced in CDI 1.1 and 1.2 and discusses improvements planned for CDI 2, such as standard support for Java SE and a light CDI version useful for embedded environments, showing how it will benefit Java.
Slides of the talk gave to Devoxx with José Paumard about new features coming in CDI 2. Java SE support, asynchronous event, Interceptor on producers...
Slides of the Java One 2015 talk "Apache DeltaSpike - the CDI Toolbox". It contains presentation of Apache DeltaSpike, the framework that extends CDI in Java or Java EE
Slides of the university I gave at Devoxx Belgium with Antonio Goncalves on CDI, Java EE and JBoss Forge.
Abstract:
-------
During this 3 hours university, you will learn some CDI basis, and will quickly dive into more advance CDI features (such as extension). Using JBoss Forge we will quickly generate a Java EE 7 web application, and then, following business requirements, we will add CDI functionalities.
This university talk will be a mixture of code and slides, focusing on CDI and Java EE 7.
--------
Video of the university is available on YouTube: http://youtu.be/LYKMaj4XKvg
Code and Slides on GitHub: https://github.com/antoinesd/cdi-forge-uni/tree/DevoxxBe2015
O Android NDK é a ferramenta que permite a utilização de código nativo (C/C++) em sua aplicação Android. Nesta apresentação conheça alguns usos interessantes do NDK, as vantagens e desvantagens de utilizá-lo, além de como começar a usar esta ferramenta com o Android Studio.
Kritis is an open-source solution for securing your software supply chain for Kubernetes applications. Kritis enforces deploy-time security policies that ensures only trusted container images are deployed on kubernetes to your cluster. With Kritis, you can require images to be signed by trusted authorities during the development process and then enforce signature validation when deploying. Kritis enables tighter control over your container environment by ensuring only verified images are integrated into production.
Talk outline:
- Introduction to the concept of binary authorization
- Live demo of using Kritis and Grafeas for deploying images with confidence in Kubernetes
- Grafeas and Kritis roadmap
At the end, attendees will gain solid understanding on the process of binary authorization and how to incorporate it in their build and deployment pipelines
Software Supply Chain Management with Grafeas and KritisAysylu Greenberg
Software Supply Chain is a collective term used to describe the continuous integration and delivery pipelines. In addition, it refers to the observability tools that track what happens to a piece of code from the moment it’s in the source code to when it gets deployed, and everywhere in between. Grafeas is an open-source artifact metadata API to audit and govern your software supply chain. It's built as an industry standard for storing and retrieving metadata about software resources. Kritis is an open-source solution for securing your software supply chain for Kubernetes applications. It enforces deploy-time security policies using Grafeas.
This talk will discuss the goals for each of the two open source projects, dive into the examples of how they can be used to secure your company's software supply chain, and conclude with the details of current and future development.
Software Supply Chain Management with Grafeas and KritisAysylu Greenberg
Software Supply Chain is a collective term used to describe the continuous integration and delivery pipelines. In addition, it refers to the observability tools that track what happens to a piece of code from the moment it’s in the source code to when it gets deployed, and everywhere in between. Grafeas is an open-source artifact metadata API to audit and govern your software supply chain. It's built as an industry standard for storing and retrieving metadata about software resources. Kritis is an open-source solution for securing your software supply chain for Kubernetes applications. It enforces deploy-time security policies using Grafeas.
This talk will discuss the goals for each of the two open source projects, dive into the examples of how they can be used to secure your company's software supply chain, and conclude with the details of current and future development.
Modules in Java? Finally! (OpenJDK 9 Jigsaw, JSR376)Mihail Stoynov
This talk is for a very important new feature in Java SE 9. Code named Jigsaw, this feature modularizes the Java SE platform.
The coolest thing we do here is to create a custom JRE
Code: https://bitbucket.org/stybz/jigsaw.sty/
PPT: https://www.slideshare.net/mihailstoynov/modules-in-java-finally-openjdk-jigsaw
Video: https://www.youtube.com/watch?v=W5LeNPtPrqw
Test-driven Development (TDD) is still a subject all developers agree is a great thing, but never get around to actually doing it for many reasons. In this workshop, I use real-world business requirements on legacy code for which we need to fix bugs and add features, but we’re doing it in a TDD way.
Trying to build an Open Source browser in 2020Patricia Aas
A lot of things have been developed over the last 15 years that should make the process of making a browser easier. In this talk we will explore a bunch of different tools, platforms and libraries that could go into making a browser in 2020.
We will also see a live demo of a simple browser built with these OSS projects. We will also discuss the limitations and future work needed to make this work in practice.
Hands on React Native: From Zero to HeroDmitry Vinnik
Abstract:
So many platforms, so little time. How do we write an app for the web, Android, iOS, and other OS without spending all our time and money? Cross-platform can be your answer!
You probably heard about React Native before, a framework that allows you to create native Android and iOS apps using React. But how do you get started with the framework? Whether you are an advanced iOS developer or a beginner React dev, this talk will help you get started with React Native.
In this session, we explore React Native and its main concepts. Then, we will build a demo app from scratch for Android and iOS to show the power of cross-platform that the framework brings to the table!
Link: https://dvinnik.dev/talks/mobile/hands-on-react-native/
TDD is now mainstream but a lot people don't know or don't remember what is its purpose. TDD is about software design not testing or catching bug. TDD helps developers to shape and create software with "good" design, what is a "good" design is something that we will discuss in the topic.
TDD is now mainstream but a lot people don't know or don't remember what is its purpose. TDD is about software design not testing or catching bug. TDD helps developers to shape and create software with "good" design, what is a "good" design is something that we will discuss in the topic.
Sempre se perguntou como funciona o desenvolvimento iOS em um ambiente profissional? Será mesmo que a gente faz archive na mão e perde 1 hora porque esqueceu de incrementar o número do build? E sofre toda vez que precisa subir algo no test flight?
Vou falar de:
*Git Flow - Branches, PullRequests, Code Review*
(Como evitar conflitos e garantir que o código que subiu foi revisado)
*SwiftLint*
(Porque é importante manter padrões no código, e todos da equipe programando da mesma forma)
*Fastlane*
(Incrementar build automaticamente, rodar testes, fazer o archive, entre outros, sem precisar esperar o Xcode colaborar)
*Continuous Integration & Continuous Deploy - Bitrise*
(A mágica de como automatizar TUDO no processo de desenvolvimento)
QA Fest 2019. Boni Garcia. Web and Mobile testing with Selenium, JUnit 5, and...QAFest
Selenium has become the de facto standard framework for end-to-end web testing nowadays. It allows to drive programmatically web browsers, such as Chrome, Firefox, etc. This talk presents Selenium-Jupiter (https://github.com/bonigarcia/selenium-jupiter), an open-source JUnit 5 extension aimed to provide seamless integration with Selenium and Appium. JUnit is the most popular test frameworks for Java and one of the most influential in software engineering. JUnit 5 is the next generation of JUnit, providing a brand-new programming and extension model called Jupiter. Selenium-Jupiter is a JUnit 5 extension to use Selenium and provides a rich variety of features, including the capability to use of local or remote browsers. Moreover, it allows to use browsers and Android devices in Docker containers out of the box. Selenium-Jupiter can be used to carry out different types of test of web applications, including functional, compatibility (i.e. using different browsers types and versions) or performance (i.e. using a big number of browsers) tests.
The DevSecOps Builder’s Guide to the CI/CD PipelineJames Wickett
All organizations want to go faster and decrease friction in their cloud software delivery pipeline. Infosec has an opportunity to change their classic approach from blocker to enabler. This talk will discuss hallmarks of CI/CD and some practical examples for adding security testing across different organizations. The talk will cover emergent patterns, practices and toolchains that bring security to the table.
Presented at LASCON 2018, in Austin, TX.
This for developers who have not yet attempted the Android SDK.
This will give the needed clarity by giving the much needed initial push to setup your Windows development environment and build a sample Android application.
Slides of my tutorial I gave to Java One 2016 on advanced CDI 1.2 stuff.
Introducing CDI 1.2 SPI, Portable extension and then show how to develop fat JPA entities, asynchronous events and integration of a 3rd party framework (Dropwizard Metrics) with CDI 1.2 to enhance Java EE 7 platform.
Présentation sur Java EE / Wildfly faite au JUG SummerCamp 2015.
Venez revisiter les idées reçues sur Java EE. Cette présentation revisite les mythes autour de Java EE pour voir si ils sont toujours vrais ou faux.
O Android NDK é a ferramenta que permite a utilização de código nativo (C/C++) em sua aplicação Android. Nesta apresentação conheça alguns usos interessantes do NDK, as vantagens e desvantagens de utilizá-lo, além de como começar a usar esta ferramenta com o Android Studio.
Kritis is an open-source solution for securing your software supply chain for Kubernetes applications. Kritis enforces deploy-time security policies that ensures only trusted container images are deployed on kubernetes to your cluster. With Kritis, you can require images to be signed by trusted authorities during the development process and then enforce signature validation when deploying. Kritis enables tighter control over your container environment by ensuring only verified images are integrated into production.
Talk outline:
- Introduction to the concept of binary authorization
- Live demo of using Kritis and Grafeas for deploying images with confidence in Kubernetes
- Grafeas and Kritis roadmap
At the end, attendees will gain solid understanding on the process of binary authorization and how to incorporate it in their build and deployment pipelines
Software Supply Chain Management with Grafeas and KritisAysylu Greenberg
Software Supply Chain is a collective term used to describe the continuous integration and delivery pipelines. In addition, it refers to the observability tools that track what happens to a piece of code from the moment it’s in the source code to when it gets deployed, and everywhere in between. Grafeas is an open-source artifact metadata API to audit and govern your software supply chain. It's built as an industry standard for storing and retrieving metadata about software resources. Kritis is an open-source solution for securing your software supply chain for Kubernetes applications. It enforces deploy-time security policies using Grafeas.
This talk will discuss the goals for each of the two open source projects, dive into the examples of how they can be used to secure your company's software supply chain, and conclude with the details of current and future development.
Software Supply Chain Management with Grafeas and KritisAysylu Greenberg
Software Supply Chain is a collective term used to describe the continuous integration and delivery pipelines. In addition, it refers to the observability tools that track what happens to a piece of code from the moment it’s in the source code to when it gets deployed, and everywhere in between. Grafeas is an open-source artifact metadata API to audit and govern your software supply chain. It's built as an industry standard for storing and retrieving metadata about software resources. Kritis is an open-source solution for securing your software supply chain for Kubernetes applications. It enforces deploy-time security policies using Grafeas.
This talk will discuss the goals for each of the two open source projects, dive into the examples of how they can be used to secure your company's software supply chain, and conclude with the details of current and future development.
Modules in Java? Finally! (OpenJDK 9 Jigsaw, JSR376)Mihail Stoynov
This talk is for a very important new feature in Java SE 9. Code named Jigsaw, this feature modularizes the Java SE platform.
The coolest thing we do here is to create a custom JRE
Code: https://bitbucket.org/stybz/jigsaw.sty/
PPT: https://www.slideshare.net/mihailstoynov/modules-in-java-finally-openjdk-jigsaw
Video: https://www.youtube.com/watch?v=W5LeNPtPrqw
Test-driven Development (TDD) is still a subject all developers agree is a great thing, but never get around to actually doing it for many reasons. In this workshop, I use real-world business requirements on legacy code for which we need to fix bugs and add features, but we’re doing it in a TDD way.
Trying to build an Open Source browser in 2020Patricia Aas
A lot of things have been developed over the last 15 years that should make the process of making a browser easier. In this talk we will explore a bunch of different tools, platforms and libraries that could go into making a browser in 2020.
We will also see a live demo of a simple browser built with these OSS projects. We will also discuss the limitations and future work needed to make this work in practice.
Hands on React Native: From Zero to HeroDmitry Vinnik
Abstract:
So many platforms, so little time. How do we write an app for the web, Android, iOS, and other OS without spending all our time and money? Cross-platform can be your answer!
You probably heard about React Native before, a framework that allows you to create native Android and iOS apps using React. But how do you get started with the framework? Whether you are an advanced iOS developer or a beginner React dev, this talk will help you get started with React Native.
In this session, we explore React Native and its main concepts. Then, we will build a demo app from scratch for Android and iOS to show the power of cross-platform that the framework brings to the table!
Link: https://dvinnik.dev/talks/mobile/hands-on-react-native/
TDD is now mainstream but a lot people don't know or don't remember what is its purpose. TDD is about software design not testing or catching bug. TDD helps developers to shape and create software with "good" design, what is a "good" design is something that we will discuss in the topic.
TDD is now mainstream but a lot people don't know or don't remember what is its purpose. TDD is about software design not testing or catching bug. TDD helps developers to shape and create software with "good" design, what is a "good" design is something that we will discuss in the topic.
Sempre se perguntou como funciona o desenvolvimento iOS em um ambiente profissional? Será mesmo que a gente faz archive na mão e perde 1 hora porque esqueceu de incrementar o número do build? E sofre toda vez que precisa subir algo no test flight?
Vou falar de:
*Git Flow - Branches, PullRequests, Code Review*
(Como evitar conflitos e garantir que o código que subiu foi revisado)
*SwiftLint*
(Porque é importante manter padrões no código, e todos da equipe programando da mesma forma)
*Fastlane*
(Incrementar build automaticamente, rodar testes, fazer o archive, entre outros, sem precisar esperar o Xcode colaborar)
*Continuous Integration & Continuous Deploy - Bitrise*
(A mágica de como automatizar TUDO no processo de desenvolvimento)
QA Fest 2019. Boni Garcia. Web and Mobile testing with Selenium, JUnit 5, and...QAFest
Selenium has become the de facto standard framework for end-to-end web testing nowadays. It allows to drive programmatically web browsers, such as Chrome, Firefox, etc. This talk presents Selenium-Jupiter (https://github.com/bonigarcia/selenium-jupiter), an open-source JUnit 5 extension aimed to provide seamless integration with Selenium and Appium. JUnit is the most popular test frameworks for Java and one of the most influential in software engineering. JUnit 5 is the next generation of JUnit, providing a brand-new programming and extension model called Jupiter. Selenium-Jupiter is a JUnit 5 extension to use Selenium and provides a rich variety of features, including the capability to use of local or remote browsers. Moreover, it allows to use browsers and Android devices in Docker containers out of the box. Selenium-Jupiter can be used to carry out different types of test of web applications, including functional, compatibility (i.e. using different browsers types and versions) or performance (i.e. using a big number of browsers) tests.
The DevSecOps Builder’s Guide to the CI/CD PipelineJames Wickett
All organizations want to go faster and decrease friction in their cloud software delivery pipeline. Infosec has an opportunity to change their classic approach from blocker to enabler. This talk will discuss hallmarks of CI/CD and some practical examples for adding security testing across different organizations. The talk will cover emergent patterns, practices and toolchains that bring security to the table.
Presented at LASCON 2018, in Austin, TX.
This for developers who have not yet attempted the Android SDK.
This will give the needed clarity by giving the much needed initial push to setup your Windows development environment and build a sample Android application.
Slides of my tutorial I gave to Java One 2016 on advanced CDI 1.2 stuff.
Introducing CDI 1.2 SPI, Portable extension and then show how to develop fat JPA entities, asynchronous events and integration of a 3rd party framework (Dropwizard Metrics) with CDI 1.2 to enhance Java EE 7 platform.
Présentation sur Java EE / Wildfly faite au JUG SummerCamp 2015.
Venez revisiter les idées reçues sur Java EE. Cette présentation revisite les mythes autour de Java EE pour voir si ils sont toujours vrais ou faux.
CDI portable extensions are one of greatest features of Java EE allowing the platform to be extended in a clean and portable way. But allowing extension is just part of the story. CDI opens the door to a whole new eco-system for Java EE, but it’s not the role of the specification to create these extensions.
Apache DeltaSpike is the project that leads this brand new eco-system by providing useful extension modules for CDI applications as well as tools to ease the creation of new ones.
In this session, we’ll start by presenting the DeltaSpike toolbox and show how it helps you to develop for CDI. Then we’ll describe the major extensions included in DeltaSpike, including 'configuration', 'scheduling' and 'data'.
This slides were used in a 2014 Devoxx university. They covers advanced CDI topics such as metadata injection manipulation and portable extension development. it shows advanced features in CDI on the theoretical and practical sides. They show how to integrate legacy code, how to extend CDI to integrate an existing framework and how to use CDI to create a new powerful framework.
Cette présentation est le support d'une Université faite à Devoxx par Mathieu Ancelin (Serli) et moi même. Elle propose une exploration pratique des fonctionnalités de CDI et de quelques extensions Seam 3 à travers le module Seam Social (solution d'interconnexion aux réseaux sociaux).
Les sujets suivants seront abordés :
Retour rapide sur la spécification CDI
Création et manipulation de Bean CDI
Création d'extension CDI
Utilisation d'événements CDI
Création de décorateurs et intercepteurs CDI
Extension de CDI pour une approche modulaire grace à Weld OSGI
Création d'une appli web cliente se connectant à plusieurs services (Twitter, Facebook LinkedIn)
1/3 : introduction to CDI - Antoine Sabot-DurandSOAT
Allez plus Loin avec CDI
En moins de 5 ans d’existence, Contexts and Dependency Injection (CDI) est devenue l’une des principale spécification de Java EE. Néanmoins, CDI est bien souvent perçu comme une simple solution d’injection de dépendance enrichie alors que cette spécification est bien plus riche que ça. Lors de cette présentation, après un rapide rappel des fonctionnalités de base de CDI, nous montrerons comment son utilisation avancée permet Java EE en intégrant des technologies legacy ou plus récent de manière naturelle. Nous finirons avec le travail en cours sur CDI 2.0 qui a commencé début septembre.
Slides de la conférence donnée par Alexis Hassler et Antoine Sabot-Durand à Devoxx France 2014 sur les possibilités d'extensions de Java EE. Y sont évoqués l'utilisation de CDI et de son système d'extension ainsi que de JCA à travers le développement d'un connecteur MQTT.
Git Tutorial A Comprehensive Guide for Beginners.pdfuzair
flicts
If there are conflicts when merging changes, Git will prompt you to resolve them. You can use a variety of tools to resolve conflicts, including text editors and graphical merge tools.
Advanced Git Commands
git diff
The git diff command shows the differences between two different versions of a file:
phpCopy code
git diff <commit1> <commit2> <file>
git reset
The git reset command is used to reset the state of the repository to a specific commit:
perlCopy code
git reset <commit>
git stash
The git stash command is used to temporarily save changes that you are not yet ready to commit:
Copy code
git stash
Git Best Practices
Committing frequently
It is important to commit your changes frequently, rather than waiting until you have completed a large amount of work. This makes it easier to track changes and identify problems.
Writing meaningful commit messages
Your commit messages should be descriptive and provide context for the changes that you have made.
Creating descriptive branch names
Your branch names should be descriptive and provide context for the changes that you are working on.
Conclusion
In this guide, we have covered the basic concepts of Git, how to install it, and the
Git can be a complex tool, but with practice and experience, you will become more comfortable using it. If you have any questions or run into any issues, there is a wealth of resources available online, including documentation, forums, and tutorials.
Thank you for reading this comprehensive guide to Git for beginners.
FAQ
It provides a number of benefits, including the ability to collaborate with others, maintain a history of your code, and easily revert changes if necessary.
What is a repository in Git? A repository is a central location where your code is stored and managed. It contains all of the files and directories that make up your project, as well as a history of changes made to those files.
What is branching in Git? Branching is the process of creating a new line of development for your code. It allows you to work on new features or changes without affecting the main branch of your code.
How do I resolve merge conflicts in Git? When merging changes from one branch into another, you may encounter conflicts between different versions of the same file. Git provides tools to help you resolve these conflicts, including text editors and graphical meflicts
If there are conflicts when merging changes, Git will prompt you to resolve them. You can use a variety of tools to resolve conflicts, including text editors and graphical merge tools.
Advanced Git Commands
git diff
The git diff command shows the differences between two different versions of a file:
phpCopy code
git diff <commit1> <commit2> <file>
git reset
The git reset command is used to reset the state of the repository to a specific commit:
perlCopy code
git reset <commit>
git stash
The git stash command is used to temporarily save changes that you are not yet ready to commit:
Copy code
git sta
You can’t throw a party, if the front door is blocked. More than 60% of users sign up for a service, bounce during onboarding, and never return. If your company depends on developers, then how they get started, use, and contribute to your communities, libraries, tools and APIs should be more than just painless. Your onboarding design should be elegant. In this Heavybit Speaker Series presentation, GitHub Developer Advocate Brian Douglas will discuss:
Best practices in designing a stellar first user experience;
Tools, content and tactics to maintain user momentum; and,
Examples of the breadcrumbs and carrots that communities like GitHub, Netlify, Stripe and Graphcool use to help developers succeed
La importancia de versionar el código: GitHub, portafolio y recursos para est...CloudNativeElSalvado
Hoy en día el uso de una herramienta de versionado de código es un elemento base para todo programador. Pero, ¿Sabías que te puede servir de portafolio? o que también puedes versionar infraestructura? y ¿Sabías que GitHub ofrece un paquete con muchos beneficios gratuitos para estudiantes de parte de sus socios? Sé parte de este evento y entérate de esto y más.
AGENDA
¿Qué es Git y para qué se utiliza?
Comandos básicos de Git
Trabajar en equipo con Git
Importancia de tener un portafolio en Git
Deployment
Beneficios de GitHub para estudiantes
This is a python course for beginners, intended both for frontal class learning as well as self-work.
The Course is designed for 2 days and then another week of HW assignments.
A startup with no office, hipster tools and open source productsFrank Rousseau
This how we are organized at Cozy Cloud, a very young startup with no office and open source products: light agile method, teleworking, open source and fun !
https://cozycloud.cc/
Talk performed @ LyonJS Meetup, April 2013
For the full video of this presentation, please visit: https://www.edge-ai-vision.com/2022/06/tensorflow-lite-for-microcontrollers-tflm-recent-developments-a-presentation-from-bdti-and-google/
David Davis, Senior Embedded Software Engineer, and John Withers, Automation and Systems Engineer, both of BDTI, present the “TensorFlow Lite for Microcontrollers (TFLM): Recent Developments” tutorial at the May 2022 Embedded Vision Summit.
TensorFlow Lite Micro (TFLM) is a generic inference framework designed to run TensorFlow models on digital signal processors (DSPs), microcontrollers and other embedded targets with small memory footprints and very low power usage. TFLM aims to be easily portable to various embedded targets from those running an RTOS to bare-metal code. TFLM leverages the model optimization tools from the TensorFlow ecosystem and has additional embedded-specific optimizations to reduce the memory footprint. TFLM also integrates with a number of community contributed optimized hardware-specific kernel implementations.
In this talk, Davis and Withers review collaboration between BDTI and Google over the last year, including porting nearly two dozen operators from TensorFlow Lite to TFLM, creation of a separate Arduino examples repository, improved testing and documentation of both Arduino and Colab training examples and transitioning TFLM’s open-source CI framework to use GitHub Actions.
Talk at PyCon2022 over building binary packages for Python. Covers an overview and an in-depth look into pybind11 for binding, scikit-build for creating the build, and build & cibuildwheel for making the binaries that can be distributed on PyPI.
Continuous Delivery for Python Developers – PyCon OttoPeter Bittner
Continuous Delivery sounds easy in theory, but it’s hard to do in practice. There are myriads of things you can and should do to get your code delivered faster, reliably. We look at what we can do as Python developers, or as a small or mid-sized team to make the industrialized software development production chain come true.
Connector Corner: Automate dynamic content and events by pushing a buttonDianaGray10
Here is something new! In our next Connector Corner webinar, we will demonstrate how you can use a single workflow to:
Create a campaign using Mailchimp with merge tags/fields
Send an interactive Slack channel message (using buttons)
Have the message received by managers and peers along with a test email for review
But there’s more:
In a second workflow supporting the same use case, you’ll see:
Your campaign sent to target colleagues for approval
If the “Approve” button is clicked, a Jira/Zendesk ticket is created for the marketing design team
But—if the “Reject” button is pushed, colleagues will be alerted via Slack message
Join us to learn more about this new, human-in-the-loop capability, brought to you by Integration Service connectors.
And...
Speakers:
Akshay Agnihotri, Product Manager
Charlie Greenberg, Host
GDG Cloud Southlake #33: Boule & Rebala: Effective AppSec in SDLC using Deplo...James Anderson
Effective Application Security in Software Delivery lifecycle using Deployment Firewall and DBOM
The modern software delivery process (or the CI/CD process) includes many tools, distributed teams, open-source code, and cloud platforms. Constant focus on speed to release software to market, along with the traditional slow and manual security checks has caused gaps in continuous security as an important piece in the software supply chain. Today organizations feel more susceptible to external and internal cyber threats due to the vast attack surface in their applications supply chain and the lack of end-to-end governance and risk management.
The software team must secure its software delivery process to avoid vulnerability and security breaches. This needs to be achieved with existing tool chains and without extensive rework of the delivery processes. This talk will present strategies and techniques for providing visibility into the true risk of the existing vulnerabilities, preventing the introduction of security issues in the software, resolving vulnerabilities in production environments quickly, and capturing the deployment bill of materials (DBOM).
Speakers:
Bob Boule
Robert Boule is a technology enthusiast with PASSION for technology and making things work along with a knack for helping others understand how things work. He comes with around 20 years of solution engineering experience in application security, software continuous delivery, and SaaS platforms. He is known for his dynamic presentations in CI/CD and application security integrated in software delivery lifecycle.
Gopinath Rebala
Gopinath Rebala is the CTO of OpsMx, where he has overall responsibility for the machine learning and data processing architectures for Secure Software Delivery. Gopi also has a strong connection with our customers, leading design and architecture for strategic implementations. Gopi is a frequent speaker and well-known leader in continuous delivery and integrating security into software delivery.
JMeter webinar - integration with InfluxDB and GrafanaRTTS
Watch this recorded webinar about real-time monitoring of application performance. See how to integrate Apache JMeter, the open-source leader in performance testing, with InfluxDB, the open-source time-series database, and Grafana, the open-source analytics and visualization application.
In this webinar, we will review the benefits of leveraging InfluxDB and Grafana when executing load tests and demonstrate how these tools are used to visualize performance metrics.
Length: 30 minutes
Session Overview
-------------------------------------------
During this webinar, we will cover the following topics while demonstrating the integrations of JMeter, InfluxDB and Grafana:
- What out-of-the-box solutions are available for real-time monitoring JMeter tests?
- What are the benefits of integrating InfluxDB and Grafana into the load testing stack?
- Which features are provided by Grafana?
- Demonstration of InfluxDB and Grafana using a practice web application
To view the webinar recording, go to:
https://www.rttsweb.com/jmeter-integration-webinar
Software Delivery At the Speed of AI: Inflectra Invests In AI-Powered QualityInflectra
In this insightful webinar, Inflectra explores how artificial intelligence (AI) is transforming software development and testing. Discover how AI-powered tools are revolutionizing every stage of the software development lifecycle (SDLC), from design and prototyping to testing, deployment, and monitoring.
Learn about:
• The Future of Testing: How AI is shifting testing towards verification, analysis, and higher-level skills, while reducing repetitive tasks.
• Test Automation: How AI-powered test case generation, optimization, and self-healing tests are making testing more efficient and effective.
• Visual Testing: Explore the emerging capabilities of AI in visual testing and how it's set to revolutionize UI verification.
• Inflectra's AI Solutions: See demonstrations of Inflectra's cutting-edge AI tools like the ChatGPT plugin and Azure Open AI platform, designed to streamline your testing process.
Whether you're a developer, tester, or QA professional, this webinar will give you valuable insights into how AI is shaping the future of software delivery.
GraphRAG is All You need? LLM & Knowledge GraphGuy Korland
Guy Korland, CEO and Co-founder of FalkorDB, will review two articles on the integration of language models with knowledge graphs.
1. Unifying Large Language Models and Knowledge Graphs: A Roadmap.
https://arxiv.org/abs/2306.08302
2. Microsoft Research's GraphRAG paper and a review paper on various uses of knowledge graphs:
https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/
Dev Dives: Train smarter, not harder – active learning and UiPath LLMs for do...UiPathCommunity
💥 Speed, accuracy, and scaling – discover the superpowers of GenAI in action with UiPath Document Understanding and Communications Mining™:
See how to accelerate model training and optimize model performance with active learning
Learn about the latest enhancements to out-of-the-box document processing – with little to no training required
Get an exclusive demo of the new family of UiPath LLMs – GenAI models specialized for processing different types of documents and messages
This is a hands-on session specifically designed for automation developers and AI enthusiasts seeking to enhance their knowledge in leveraging the latest intelligent document processing capabilities offered by UiPath.
Speakers:
👨🏫 Andras Palfi, Senior Product Manager, UiPath
👩🏫 Lenka Dulovicova, Product Program Manager, UiPath
Elevating Tactical DDD Patterns Through Object CalisthenicsDorra BARTAGUIZ
After immersing yourself in the blue book and its red counterpart, attending DDD-focused conferences, and applying tactical patterns, you're left with a crucial question: How do I ensure my design is effective? Tactical patterns within Domain-Driven Design (DDD) serve as guiding principles for creating clear and manageable domain models. However, achieving success with these patterns requires additional guidance. Interestingly, we've observed that a set of constraints initially designed for training purposes remarkably aligns with effective pattern implementation, offering a more ‘mechanical’ approach. Let's explore together how Object Calisthenics can elevate the design of your tactical DDD patterns, offering concrete help for those venturing into DDD for the first time!
Encryption in Microsoft 365 - ExpertsLive Netherlands 2024Albert Hoitingh
In this session I delve into the encryption technology used in Microsoft 365 and Microsoft Purview. Including the concepts of Customer Key and Double Key Encryption.
Securing your Kubernetes cluster_ a step-by-step guide to success !KatiaHIMEUR1
Today, after several years of existence, an extremely active community and an ultra-dynamic ecosystem, Kubernetes has established itself as the de facto standard in container orchestration. Thanks to a wide range of managed services, it has never been so easy to set up a ready-to-use Kubernetes cluster.
However, this ease of use means that the subject of security in Kubernetes is often left for later, or even neglected. This exposes companies to significant risks.
In this talk, I'll show you step-by-step how to secure your Kubernetes cluster for greater peace of mind and reliability.
20. This SPI can be used in your code (2/2)
InjectionPoint contains info about requested type at @Inject
class MyMapProducer() {
@Produces
<K, V> Map<K, V> produceMap(InjectionPoint ip) {
if (valueIsNumber(((ParameterizedType) ip.getType())))
return new TreeMap<K, V>();
return new HashMap<K, V>();
}
boolean valueIsNumber(ParameterizedType type) {
Class<?> valueClass = (Class<?>) type.getActualTypeArguments()[1];
return Number.class.isAssignableFrom(valueClass)
}
}
33. Dropwizard Metrics provides
Different metric types: Counter , Gauge , Meter , Timer , …
Different reporter: JMX, console, SLF4J, CSV, servlet, …
MetricRegistry object which collects all your app metrics
Annotations for AOP frameworks: @Counted , @Timed , …
… but does not include integration with these frameworks
More at dropwizard.github.io/metrics
40. Solving the ambiguity
We could use the provided @Metric annotation to qualify our beans
@Produces
@Metric(name = "myTimer")
Timer timer = new Timer(new SlidingTimeWindowReservoir(1L, MINUTES));
@Produces
@Metric(name = "mySecondTimer")
Timer timer = new Timer(new SlidingTimeWindowReservoir(1L, HOURS));
@Inject
@Metric(name = "myTimer")
Timer timer;
That won’t work out of the box since @Metric is not a qualifier
41. How to make @Metric a qualifier?
By observing BeforeBeanDiscovery lifecycle event in an extension
public interface BeforeBeanDiscovery {
addQualifier(Class<? extends Annotation> qualifier);
addQualifier(AnnotatedType<? extends Annotation> qualifier);
addScope(Class<? extends Annotation> scopeType, boolean normal, boolean passivation);
addStereotype(Class<? extends Annotation> stereotype, Annotation... stereotypeDef);
addInterceptorBinding(AnnotatedType<? extends Annotation> bindingType);
addInterceptorBinding(Class<? extends Annotation> bindingType, Annotation... bindingTypeDef);
addAnnotatedType(AnnotatedType<?> type);
addAnnotatedType(AnnotatedType<?> type, String id);
}
This method is the one we need to declare @Metric as qualifier
And use addQualifier() method in the event
1
1
42. Internal Step Happen Once Loop on Elements
BeforeBeanDiscovery is first in lifecycle
Deployment
Start
Before
Bean
Discovery
Scan
Archive
Process
Annotated
Type
After
Type
Discovery
Bean
Eligibility
Check
Process
Injection
Point
Process
Injection
Target
Process
Bean
Attributes
Process
Bean
Process
Producer
Process
Observer
Method
After
Bean
Discovery
After
Deployment
Validation
Application
Running
Before
Shutdown
Undeploy
Application
43. Our first extension
A CDI extension is a class implementing the Extension tag interface
org.cdi.further.metrics.MetricsExtension
public class MetricsExtension implements Extension {
void addMetricAsQualifier(@Observes BeforeBeanDiscovery bdd) {
bdd.addQualifier(Metric.class);
}
}
Extension is activated by adding this file to META-INF/services
javax.enterprise.inject.spi.Extension
org.cdi.further.metrics.MetricsExtension
55. Using the AnnotatedType SPI
Thanks to DeltaSpike we can easily create the required AnnotatedType
AnnotatedType createTimedAnnotatedType() throws Exception {
Annotation nonBinding = new AnnotationLiteral<Nonbinding>() {};
return new AnnotatedTypeBuilder().readFromType(Timed.class)
.addToMethod(Timed.class.getMethod("name"), nonBinding)
.addToMethod(Timed.class.getMethod("absolute"), nonBinding)
.create();
}
This creates an instance of @NonBinding annotation
It would have been possible but far more verbose to create this AnnotatedType without the help of
DeltaSpike. The AnnotatedTypeBuilder is initialized from the Metrics @Timed annotation.
@NonBinding is added to both members of the @Timed annotation
1
2
3
3
1
2
3
56. This extension will do the job
We observe BeforeBeanDiscovery to add a new interceptor binding
public class MetricsExtension implements Extension {
void addTimedBinding(@Observes BeforeBeanDiscovery bdd) throws Exception {
Annotation nonBinding = new AnnotationLiteral<Nonbinding>() {};
bdd.addInterceptorBinding(new AnnotatedTypeBuilder<Timed>()
.readFromType(Timed.class)
.addToMethod(Timed.class.getMethod("name"), nonBinding)
.addToMethod(Timed.class.getMethod("absolute"), nonBinding)
.create());
}
}
62. Goal 3 step by step
We need to write an extension that will:
1. Change how a Metric instance is produced by looking it up in the
registry first and producing (and registering) it only if it’s not found.
We’ll do this by:
1. observing the ProcessProducer lifecycle event
2. decorating Metric Producer to add this new behavior
2. Produce all Metric instances at the end of boot time to have them in
registry for runtime
1. we’ll do this by observing AfterDeploymentValidation event
63. Internal Step Happen Once Loop on Elements
So we will @Observes these 2 events to add our features
Deployment
Start
Before
Bean
Discovery
Scan
Archive
Process
Annotated
Type
After
Type
Discovery
Bean
Eligibility
Check
Process
Injection
Point
Process
Injection
Target
Process
Bean
Attributes
Process
Bean
Process
Producer
Process
Observer
Method
After
Bean
Discovery
After
Deployment
Validation
Application
Running
Before
Shutdown
Undeploy
Application
64. Customizing Metric producing process
We first need to create our implementation of the Producer<X> SPI
class MetricProducer<X extends Metric> implements Producer<X> {
final Producer<X> decorate;
final String metricName;
MetricProducer(Producer<X> decorate, String metricName) {
this.decorate = decorate;
this.metricName = metricName;
}
//...
66. We’ll use our MetricProducer in a ProcessProducer observer
This event allow us to substitute the original producer by ours
public interface ProcessProducer<T, X> {
AnnotatedMember<T> getAnnotatedMember();
Producer<X> getProducer();
void setProducer(Producer<X> producer);
void addDefinitionError(Throwable t);
}
Gets the AnnotatedMember associated to the @Produces field or method
Gets the default producer (useful to decorate it)
Overrides the producer
1
2
3
1
2
3
67. Customizing Metric producing process (end)
Here’s the extension code to do this producer decoration
public class MetricsExtension implements Extension {
//...
<X extends Metric> void decorateMetricProducer(@Observes ProcessProducer<?, X> pp) {
String name = pp.getAnnotatedMember().getAnnotation(Metric.class).name();
pp.setProducer(new MetricProducer<>(pp.getProducer(), name));
}
//...
}
We retrieve metric name from the name() member in @Metric
We replace the original producer by our producer (which decorates the former)
1
2
1
2
68. Producing all the Metric instances at the end of boot time
We do that by observing the AfterDeploymentValidation event
public class MetricsExtension implements Extension {
//...
void registerProducedMetrics(@Observes AfterDeploymentValidation adv) {
List<Metric> metrics = BeanProvider.getContextualReferences(Metric.class, true);
}
//...
}
getContextualReferences() is a method in DeltaSpike BeanProvider helper class.
It creates the list of bean instances for a given bean type (ignoring qualifiers)
1
1
79. Our goals
1. Avoid assembling and configuring the CamelContext manually
2. Access CDI beans from the Camel DSL automatically
.to("sjms:queue:output"); // Lookup by name (sjms) and type (Component)
context.resolvePropertyPlaceholders("{{jms.maxConnections}}");
// Lookup by name (properties) and type (Component)
3. Support Camel annotations in CDI beans
@PropertyInject(value = "jms.maxConnections", defaultValue = "10")
int maxConnections;
81. How to achieve this?
We need to write an extension that will:
1. Declare a CamelContext bean by observing the AfterBeanDiscovery
lifecycle event
2. Instantiate the beans of type RouteBuilder and add them to the Camel
context
3. Start (resp. stop) the Camel context when the
AfterDeploymentValidation event is fired (resp. the BeforeShutdown
event)
4. Customize the Camel context to query the BeanManager to lookup CDI
beans by name and type
5. Detect CDI beans containing Camel annotations by observing the
ProcessAnnotatedType event and modify how they get injected by
observing the ProcessInjectionTarget lifecycle event
82. Internal Step Happen Once Loop on Elements
So we will @Observes these 5 events to add our features
Deployment
Start
Before
Bean
Discovery
Scan
Archive
Process
Annotated
Type
After
Type
Discovery
Bean
Eligibility
Check
Process
Injection
Point
Process
Injection
Target
Process
Bean
Attributes
Process
Bean
Process
Producer
Process
Observer
Method
After
Bean
Discovery
After
Deployment
Validation
Application
Running
Before
Shutdown
Undeploy
Application
83. Adding the CamelContext bean
Automatically add a CamelContext bean in the deployment archive
How to add a bean programmatically?
84. Declaring a bean programmatically
We need to implement the Bean SPI
public interface Bean<T> extends Contextual<T>, BeanAttributes<T> {
Class<?> getBeanClass();
Set<InjectionPoint> getInjectionPoints();
T create(CreationalContext<T> creationalContext); // Contextual<T>
void destroy(T instance, CreationalContext<T> creationalContext);
Set<Type> getTypes(); // BeanAttributes<T>
Set<Annotation> getQualifiers();
Class<? extends Annotation> getScope();
String getName();
Set<Class<? extends Annotation>> getStereotypes();
boolean isAlternative();
}
93. Second goal achieved 1/3
We can declare the sjms component with the @Named qualifier
class JmsComponentFactoryBean {
@Produces
@Named("sjms")
@ApplicationScoped
SjmsComponent sjmsComponent(PropertiesComponent properties) {
SjmsComponent jms = new SjmsComponent();
jms.setConnectionFactory(new ActiveMQConnectionFactory("vm://broker?..."));
jms.setConnectionCount(Integer.valueOf(properties.parseUri("{{jms.maxConnections}}")));
return component;
}
}
…
94. Second goal achieved 2/3
Declare the properties component with the @Named qualifier
class PropertiesComponentFactoryBean {
@Produces
@Named("properties")
@ApplicationScoped
PropertiesComponent propertiesComponent() {
PropertiesComponent properties = new PropertiesComponent();
properties.setLocation("classpath:camel.properties");
return properties;
}
}
…
95. Second goal achieved 3/3
And get rid of the code related to the properties and sjms
components registration
@ApplicationScoped
class CamelContextBean extends DefaultCamelContext {
@Inject
CamelContextBean(FileToJmsRouteBean route, SjmsComponent jms, PropertiesComponent properties) {
addComponent("properties", propertiesComponent);
addComponent("sjms", sjmsComponent);
addRoutes(route);
}
@PostConstruct
void startContext() {
super.start();
}
@PreDestroy
void stopContext() {
super.stop();
}
}
97. How to support custom annotations injection?
Create a custom InjectionTarget that uses the default Camel bean
post processor DefaultCamelBeanPostProcessor
public interface InjectionTarget<T> extends Producer<T> {
void inject(T instance, CreationalContext<T> ctx);
void postConstruct(T instance);
void preDestroy(T instance);
}
Hook it into the CDI injection mechanism by observing the
ProcessInjectionTarget lifecycle event
Only for beans containing Camel annotations by observing the
ProcessAnnotatedType lifecycle and using @WithAnnotations
99. Register the custom InjectionTarget
Observe the ProcessInjectionTarget lifecycle event and set the
InjectionTarget
public interface ProcessInjectionTarget<X> {
AnnotatedType<X> getAnnotatedType();
InjectionTarget<X> getInjectionTarget();
void setInjectionTarget(InjectionTarget<X> injectionTarget);
void addDefinitionError(Throwable t);
}
To decorate it with the CamelInjectionTarget
class CamelExtension implements Extension {
<T> void camelBeansPostProcessor(@Observes ProcessInjectionTarget<T> pit, BeanManager bm) {
pit.setInjectionTarget(new CamelInjectionTarget<>(pit.getInjectionTarget(), bm));
}
}