Slides for the 60 minutes workshop I presented at the virtual edition of ClueCon 2020 (ClueCon Deconstructed). The many slides cover different aspects in Janus, ranging from configuration, to plugins, how to write your own plugin, core features, recording, monitoring, and so on. Unfortunately I didn't have enough time to talk about everything, but slides should be easy to follow anyway.
Slides for the 90 minutes workshop I presented at the RTC2019 event in Beijing. The many slides cover different aspects in Janus, ranging from configuration, to plugins, how to write your own plugin, core features, recording, monitoring, and so on.
An overview on how WebRTC was written from the ground up with some specific concepts in mind, specifically to try and address Security, Authentication and Privacy the right way.
Slides on the new Janus Lua plugin, as presented at the Real-time Communications devroom at FOSDEM2018. Describes in detail what the challenges were, and how we addressed them, with a few real examples at the end (including a demo written specifically for this session).
Slides for the presentation I did remotely at Open Source World, to talk about audio-only WebRTC applications, and what we've done in Janus to improve and cover the requirements so far.
Slides for the presentation on Insertable Streams and E2EE in WebRTC I presented at the virtual edition of ClueCon 2020. After an introduction on the past and recent E2EE efforts, the slides also present some efforts to integrate the technology in the Janus WebRTC server as well.
Slides I presented at the RTC2017 event in Beijing. May be mostly familiar with those who have seen my other Janus slides, but has some more content, and new examples.
Slides for the presentation on how you can get SFUs and MCUs to actually be friends, which I presented at the virtual edition of IIT-RTC 2020. The slides cover some of the pros and cons of both, and some use cases where you may actually want to use both. At the end, a few words are spent on how to use browsers as an MCU instead, which might make them being used with SFUs even easier.
Slides for the 90 minutes workshop I presented at the RTC2019 event in Beijing. The many slides cover different aspects in Janus, ranging from configuration, to plugins, how to write your own plugin, core features, recording, monitoring, and so on.
An overview on how WebRTC was written from the ground up with some specific concepts in mind, specifically to try and address Security, Authentication and Privacy the right way.
Slides on the new Janus Lua plugin, as presented at the Real-time Communications devroom at FOSDEM2018. Describes in detail what the challenges were, and how we addressed them, with a few real examples at the end (including a demo written specifically for this session).
Slides for the presentation I did remotely at Open Source World, to talk about audio-only WebRTC applications, and what we've done in Janus to improve and cover the requirements so far.
Slides for the presentation on Insertable Streams and E2EE in WebRTC I presented at the virtual edition of ClueCon 2020. After an introduction on the past and recent E2EE efforts, the slides also present some efforts to integrate the technology in the Janus WebRTC server as well.
Slides I presented at the RTC2017 event in Beijing. May be mostly familiar with those who have seen my other Janus slides, but has some more content, and new examples.
Slides for the presentation on how you can get SFUs and MCUs to actually be friends, which I presented at the virtual edition of IIT-RTC 2020. The slides cover some of the pros and cons of both, and some use cases where you may actually want to use both. At the end, a few words are spent on how to use browsers as an MCU instead, which might make them being used with SFUs even easier.
Scaling WebRTC deployments with multicast @ IETF 110 MBONEDLorenzo Miniero
An overview of how multicast can be used to scale WebRTC deployments, with focus on the Virtual Event Platform used to provide remote participation support to IETF meetings, given during the MBONED WG session at IETF 110.
My talk on the excellent work Alessandro Toppi did at Meetecho on investigating the different code fuzzing options, and how it was eventually integrated in Janus for improving the robustness of the WebRTC stack (RTP, RTCP and SDP currently). It includes considerations on sharing corpora files and making this all distributed via OSS-Fuzz.
Ranch, Caesar or Olive Oil? Different dressings for your SIP salad with Janus! An overview of the different plugins existing (and WIP) in Janus to help with SIP needs, made at the OpenSIPS Summit 2017 in Amsterdam.
Slides for the presentation I made at ClueCon 21 on the experimental RED support in WebRTC, and how we've started tinkering with it in Janus. The presentation also addresses a more generic overview on audio features in WebRTC.
This is the presentation I made at Astricon on how to use Janus and Asterisk together for WebRTC applications. It focuses on the reasons why it might make sense to have Janus as a frontend to Asterisk, rather than let Asterisk handle WebRTC by itself, with real examples of applications doing this.
This is the slide deck I presented at the first CommCon event in the UK: it goes through some of the possible strategies for scaling WebRTC applications, mostly if you're using Janus but not only.
The slides for the "Fuzzing Janus for fun and profit" paper I presented at IPTComm 2019, in Chicago. Simon (Romano) came up with the title, as a homage to the famous "Smashing the stack for fun and profit" article.
Put some Web in your RTC SIP infrastructure! A good intro and updates on the Janus SIP and NoSIP plugins, and when it makes sense to use them (e.g., for PSTN integration, contact centers, etc.), from a presentation made at the OpenSIPS Summit 2019 in Amsterdam.
Slides for the 60 minutes "part 2" Janus workshop I presented at the virtual edition of ClueCon 2021. This time the slides covered Janus ability to bridge WebRTC and non-WebRTC applications to do interesting things, especially with the help of plain RTP and RTP forwarders. Check the conference recordings to see the actual demos in action.
Workshop on SIP/WebRTC load testing, as presented at Kamailio World 2017. May make less sense without the live demos to support it, but can still contain info some might find useful.
Janus: an open source and general purpose WebRTC (gateway) serverDevDay
Janus è un server WebRTC open source e modulare, concepito per essere a tutti gli effetti uno strumento "general purpose" per la realizzazione di complessi scenari multimediali. In quanto tale, si presta a supportare applicazioni di vario tipo, a partire da scenari più tradizionali quali conferencing, e-learning e streaming multimediale, per arrivare ad applicazioni più innovative che coinvolgano dispositivi eterogenei. La presentazione partirà da una breve panoramica su WebRTC, per coprire poi l'architettura di Janus e le possibili topologie di utilizzo, fino a presentare alcuni esempi reali di utilizzo e casi d'uso di successo.
Lorenzo Miniero
Lorenzo Miniero è uno dei fondatori di Meetecho, azienda specializzata in applicazioni multimediali e comunicazioni in real-time. Lorenzo ha conseguito laurea e dottorato di ricerca presso l'Università di Napoli Federico II, università della quale la stessa Meetecho è spin-off accademico. È un attivo "contributor" alle attività di standardizzazione della Internet Engineering Task Force (IETF), ed è noto principalmente come l'autore del server WebRTC open source Janus.
This is an introduction on Janus and its WebRTC features to the ClueCon audience, with a few words on how it can be used to complement FreeSwitch in some interesting scenarios.
Slides for the talk I made at IIT-RTC 2021 about WHIP (WebRTC-HTTP ingestion protocol) and how it can help foster adoption of WebRTC in traditional broadcasting tools. The slides also cover my open source implementations of WHIP server (based on Janus) and WHIP client (based on GStreamer), and interoperability tests with other implementations.
My (quite boring) slides on what we needed to do in Janus to support multiple streams of the same type (e.g., 3 video streams) on the same PeerConnection.
Building WebRTC based interesting features and services . WebRTC to stream from remote machine in IOT.
Details of Ramudroid a bot meant for cleaning outdoors uses webrtc stream for remote navigation .
Slides for the "WebRTC broadcasting: standardization, challenges and opportunities" presentation I made at TADSummit 2023 in Paris. It presents the problems traditional broadcasting has with new scenarios that would benefit from a much lower latency solution, and how WebRTC can help. It also introduces the standard WHIP and WHEP protocols for ingestion and egress, with a few details on how a WebRTC stream could be scaled to a very wide audience using something like SOLEIL (Streaming Of Large scale Events over Internet cLouds).
These slides cover a workshop called "Having fun with Janus and WebRTC" at the virtual edition of OpenSIPS 2021. The workshop guided viewers to how they could use different features in Janus to build a WebRTC Social TV application, including how to write a new plugin in JavaScript to build a virtual remote.
Scaling WebRTC deployments with multicast @ IETF 110 MBONEDLorenzo Miniero
An overview of how multicast can be used to scale WebRTC deployments, with focus on the Virtual Event Platform used to provide remote participation support to IETF meetings, given during the MBONED WG session at IETF 110.
My talk on the excellent work Alessandro Toppi did at Meetecho on investigating the different code fuzzing options, and how it was eventually integrated in Janus for improving the robustness of the WebRTC stack (RTP, RTCP and SDP currently). It includes considerations on sharing corpora files and making this all distributed via OSS-Fuzz.
Ranch, Caesar or Olive Oil? Different dressings for your SIP salad with Janus! An overview of the different plugins existing (and WIP) in Janus to help with SIP needs, made at the OpenSIPS Summit 2017 in Amsterdam.
Slides for the presentation I made at ClueCon 21 on the experimental RED support in WebRTC, and how we've started tinkering with it in Janus. The presentation also addresses a more generic overview on audio features in WebRTC.
This is the presentation I made at Astricon on how to use Janus and Asterisk together for WebRTC applications. It focuses on the reasons why it might make sense to have Janus as a frontend to Asterisk, rather than let Asterisk handle WebRTC by itself, with real examples of applications doing this.
This is the slide deck I presented at the first CommCon event in the UK: it goes through some of the possible strategies for scaling WebRTC applications, mostly if you're using Janus but not only.
The slides for the "Fuzzing Janus for fun and profit" paper I presented at IPTComm 2019, in Chicago. Simon (Romano) came up with the title, as a homage to the famous "Smashing the stack for fun and profit" article.
Put some Web in your RTC SIP infrastructure! A good intro and updates on the Janus SIP and NoSIP plugins, and when it makes sense to use them (e.g., for PSTN integration, contact centers, etc.), from a presentation made at the OpenSIPS Summit 2019 in Amsterdam.
Slides for the 60 minutes "part 2" Janus workshop I presented at the virtual edition of ClueCon 2021. This time the slides covered Janus ability to bridge WebRTC and non-WebRTC applications to do interesting things, especially with the help of plain RTP and RTP forwarders. Check the conference recordings to see the actual demos in action.
Workshop on SIP/WebRTC load testing, as presented at Kamailio World 2017. May make less sense without the live demos to support it, but can still contain info some might find useful.
Janus: an open source and general purpose WebRTC (gateway) serverDevDay
Janus è un server WebRTC open source e modulare, concepito per essere a tutti gli effetti uno strumento "general purpose" per la realizzazione di complessi scenari multimediali. In quanto tale, si presta a supportare applicazioni di vario tipo, a partire da scenari più tradizionali quali conferencing, e-learning e streaming multimediale, per arrivare ad applicazioni più innovative che coinvolgano dispositivi eterogenei. La presentazione partirà da una breve panoramica su WebRTC, per coprire poi l'architettura di Janus e le possibili topologie di utilizzo, fino a presentare alcuni esempi reali di utilizzo e casi d'uso di successo.
Lorenzo Miniero
Lorenzo Miniero è uno dei fondatori di Meetecho, azienda specializzata in applicazioni multimediali e comunicazioni in real-time. Lorenzo ha conseguito laurea e dottorato di ricerca presso l'Università di Napoli Federico II, università della quale la stessa Meetecho è spin-off accademico. È un attivo "contributor" alle attività di standardizzazione della Internet Engineering Task Force (IETF), ed è noto principalmente come l'autore del server WebRTC open source Janus.
This is an introduction on Janus and its WebRTC features to the ClueCon audience, with a few words on how it can be used to complement FreeSwitch in some interesting scenarios.
Slides for the talk I made at IIT-RTC 2021 about WHIP (WebRTC-HTTP ingestion protocol) and how it can help foster adoption of WebRTC in traditional broadcasting tools. The slides also cover my open source implementations of WHIP server (based on Janus) and WHIP client (based on GStreamer), and interoperability tests with other implementations.
My (quite boring) slides on what we needed to do in Janus to support multiple streams of the same type (e.g., 3 video streams) on the same PeerConnection.
Building WebRTC based interesting features and services . WebRTC to stream from remote machine in IOT.
Details of Ramudroid a bot meant for cleaning outdoors uses webrtc stream for remote navigation .
Slides for the "WebRTC broadcasting: standardization, challenges and opportunities" presentation I made at TADSummit 2023 in Paris. It presents the problems traditional broadcasting has with new scenarios that would benefit from a much lower latency solution, and how WebRTC can help. It also introduces the standard WHIP and WHEP protocols for ingestion and egress, with a few details on how a WebRTC stream could be scaled to a very wide audience using something like SOLEIL (Streaming Of Large scale Events over Internet cLouds).
These slides cover a workshop called "Having fun with Janus and WebRTC" at the virtual edition of OpenSIPS 2021. The workshop guided viewers to how they could use different features in Janus to build a WebRTC Social TV application, including how to write a new plugin in JavaScript to build a virtual remote.
SymfonyCon Madrid 2014 - Rock Solid Deployment of Symfony AppsPablo Godel
Web applications are becoming increasingly more complex, so deployment is not just transferring files with FTP anymore. We will go over the different challenges and how to deploy our PHP applications effectively, safely and consistently with the latest tools and techniques. We will also look at tools that complement deployment with management, configuration and monitoring.
Continuous Integration with Open Source Tools - PHPUgFfm 2014-11-20Michael Lihs
Presentation about open source tools to set up continuous integration and continuous deployment. Covers Git, Gitlab, Chef, Vagrant, Jenkins, Gatling, Dashing, TYPO3 Surf and some other tools. Shows some best practices for testing with Behat and Functional Testing.
Pack is a one-stop solution for packaging, distributing and deploying applications. It is able to generate cross platform, Java-based installers that both encompass and embrace the target operating systems heterogeneity (Windows, Mac OS X, Linux, *BSD, Solaris). IzPack is by no mean rigid and lets you compose your installers the way you want through a wide range of existing features and extension points.
This talk will outline: the IzPack features, its use-cases and positioning against other deployment solutions, the history of the project, from a fun hack made in a student dorm-room to an industry-backed international project thoughts on building a project community, licensing matters, sustaining/scaling a project in the long term and business-model considerations.
Symfony Live NYC 2014 - Rock Solid Deployment of Symfony AppsPablo Godel
Web applications are becoming increasingly more complex, so deployment is not just transferring files with FTP anymore. We will go over the different challenges and how to deploy our PHP applications effectively, safely and consistently with the latest tools and techniques. We will also look at tools that complement deployment with management, configuration and monitoring.
The challenges of hybrid meetings @ CommCon 2023Lorenzo Miniero
Slides for "The challenges of hybrid meetings" presentation I made at CommCon 2023. It covers how we provided remote participation services to live events before the pandemic, how we had to refactor everything for virtual only events, and what had to be changed again to accomodate audiences that may be evenly split between local and remote participants, with IETF meetings as a practical test case.
Presentation on Janus made at DevDay in Napoli (Italy).
While the presentation was in Italian (https://www.youtube.com/watch?v=gArqopeNQY0) all the slides are in English.
This talk will try to cover the most important techniques and best practices used when creating Django web application.
Overview of the topics covered:
- development general principles and goals
- python/django project initial setup - project layout, git&venv&pip&shell, settings
- central project shell command - contains all commands to manage project
- "IDE" - editor & shell
- edit/run/test cycle
- deploy/test-remotely cycle
Disclaimer: techniques and practices presented are current AUTHOR'S optimal choice used for usual django project.
My Stackato presentation given to the CopenhagenJS user group. Basic examples were implemented in Node.
More information available at: https://logiclab.jira.com/wiki/display/OPEN/Stackato
Gentoo Linux, or Why in the World You Should Compile EverythingDonnie Berkholz
Gentoo Linux is a special flavor of Linux that can be automatically optimized and customized for just about any application or need. Extreme performance, configurability and a top-notch user and developer community are all hallmarks of the Gentoo experience.
As a leader of Gentoo, I will provide an overview of how it works from a developer's and a user's point of view, and why you should be running it especially if you're:
- In need of an awesome development environment;
- Interested in learning what's inside the black box of Linux;
- OCD about having a perfectly configured setup; or
- Building an embedded, minimal system or a high-performance cluster.
If there's interest, I can also talk about future developments on the horizon for Gentoo, package management in general, etc.
My 6th. revision of my Stackato presentation given at the German Perl Workshop 2013 in Berlin, Germany,
More information available at: https://logiclab.jira.com/wiki/display/OPEN/Stackato
Slides for the talk I made at the virtual edition of FOSDEM 2022, on how to use WHIP for WebRTC broadcasting ingestion, and how the distribution process could be done via WebRTC as well, e.g., via Janus (and the SOLEIL architecture).
WebRTC and SIP not just audio and video @ OpenSIPS 2024Lorenzo Miniero
Slides for my "WebRTC-to-SIP and back: it's not all about audio and video" presentation at the OpenSIPS Summit 2024.
They describe my prototype efforts to add gatewaying support for a few SIP application protocols (T.140 for real-time text and MSRP) to Janus via data channels, with the related implementation challenges and the interesting opportunities they open.
Slides for my "Am I sober or am I trunk? A Janus story" presentation at Kamailio World 2024.
They describe my prototype efforts to add an option to create a trunk between a Janus instance and a SIP server, with the related implementation challenges and the interesting opportunities it opens.
Getting AV1/SVC to work in the Janus WebRTC ServerLorenzo Miniero
Slides for the "Getting AV1/SVC to work in the Janus WebRTC Server" presentation I made at the Real-Time Communications devroom of FOSDEM 2024 in Brussels. It describes in detail how AV1 is used in real-time communications (e.g., RTP packetization rules) and how the Dependency Descriptor extensions allows for SVC to be used in a server, by sharing my experience integrating it in the Janus WebRTC Server.
Slides for the "Bandwidth Estimation in the Janus WebRTC Server" presentation I made at the new RTC.ON event in Krakow. It covers my journey in BWE, starting from the existing options, up to the decision to start from scratch and create a new approach to create a Janus-based testbed for simulcast subscribers.
Real-Time Text and WebRTC @ Kamailio World 2023Lorenzo Miniero
Slides for my "Bringing real-time text to WebRTC for NG Emergency Services" presentation at Kamailio World 2023.
They describe my prototype efforts to get SIP-based T.140 Real-Time Text to work with WebRTC endpoints via data channels, thanks to Janus acting as a gateway for the purpose.
Slides I presented in the Open Media devroom at FOSDEM 2023, where I gave an intro on how to capture, record and produce music using just open source software on Linux. It's a very high level overview on available software to do different things, and how they can be used together using JACK and/or Pipewire.
These are the slides for the presentation I shared at the virtual edition of IIT-RTC 2022. I talked about how cascading/scalability worked with Janus 0.x, and what steps we've taken to do the same for 1.x (multistream) as well. In particular, the focus is on the new integrated cascading support in the VideoRoom plugin.
SIP transfer with Janus/WebRTC @ OpenSIPS 2022Lorenzo Miniero
These are the slides I presented at the OpenSIPS Summit 2022, where I talked about support for SIP call transfer and multiple lines in Janus, to make those features available to SIP-unaware WebRTC endpoints easily. The presentation also included a few details on a practical interaction with OpenSIPS instances.
Just a few slides to talk about the first efforts on JamRTC, a native application based on GStreamer to do live jam sessions using WebRTC and Janus as an SFU. Mostly an overview of the initial architecture, with questions at the end to figure out if the approach is right or not, how to minimize latency, etc.
Virtual IETF meetings with WebRTC @ IETF 109 MOPSLorenzo Miniero
An overview of how the Janus WebRTC Server was used to serve virtual IETF meetings at scale, with focus on how audio and video streams were handled in different ways, given during the MOPS WG session at IETF 109. Some considerations on some specific enhancements made between IETF 108 and 109 are provided as well.
Slides for the "Turning live events to virtual with Janus" talk I presented at the Virtual CommCon 2020 edition. It covers how we streamed live events in the past, and how we had to shift to a completely virtual approach because of the troubling times we live in.
An overview on the different ways Janus can interact with endpoints dealing with plain RTP, whether it's for receiving and sending media, and thus allow Janus to act as a WebRTC "enabler" for non-WebRTC infrastructures,
The slides for a talk I presented at the WebRTC track of IIT-RTC in Chicago, titled "SFU's, Simulcast and SVC: what's new in WebRTC?". Mostly a high-level introduction to how simulcast and SVC work (or not) today in browsers, how they came to be and where they might be headed from a standards perspective.
Welcome to JanusCon! -- Past, Present and Future of JanusLorenzo Miniero
The slides for my "Welcome" presentation at JanusCon '19, with an overview on the history of Janus (how it changed in this first five years) and on some possible future directions for the project. Unfortunately, my talk was not recorded, so some slides may look a bit "cryptic" without some vocal context.
Neuro-symbolic is not enough, we need neuro-*semantic*Frank van Harmelen
Neuro-symbolic (NeSy) AI is on the rise. However, simply machine learning on just any symbolic structure is not sufficient to really harvest the gains of NeSy. These will only be gained when the symbolic structures have an actual semantics. I give an operational definition of semantics as “predictable inference”.
All of this illustrated with link prediction over knowledge graphs, but the argument is general.
UiPath Test Automation using UiPath Test Suite series, part 4DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 4. In this session, we will cover Test Manager overview along with SAP heatmap.
The UiPath Test Manager overview with SAP heatmap webinar offers a concise yet comprehensive exploration of the role of a Test Manager within SAP environments, coupled with the utilization of heatmaps for effective testing strategies.
Participants will gain insights into the responsibilities, challenges, and best practices associated with test management in SAP projects. Additionally, the webinar delves into the significance of heatmaps as a visual aid for identifying testing priorities, areas of risk, and resource allocation within SAP landscapes. Through this session, attendees can expect to enhance their understanding of test management principles while learning practical approaches to optimize testing processes in SAP environments using heatmap visualization techniques
What will you get from this session?
1. Insights into SAP testing best practices
2. Heatmap utilization for testing
3. Optimization of testing processes
4. Demo
Topics covered:
Execution from the test manager
Orchestrator execution result
Defect reporting
SAP heatmap example with demo
Speaker:
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
Smart TV Buyer Insights Survey 2024 by 91mobiles.pdf91mobiles
91mobiles recently conducted a Smart TV Buyer Insights Survey in which we asked over 3,000 respondents about the TV they own, aspects they look at on a new TV, and their TV buying preferences.
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
DevOps and Testing slides at DASA ConnectKari Kakkonen
My and Rik Marselis slides at 30.5.2024 DASA Connect conference. We discuss about what is testing, then what is agile testing and finally what is Testing in DevOps. Finally we had lovely workshop with the participants trying to find out different ways to think about quality and testing in different parts of the DevOps infinity loop.
Essentials of Automations: Optimizing FME Workflows with ParametersSafe Software
Are you looking to streamline your workflows and boost your projects’ efficiency? Do you find yourself searching for ways to add flexibility and control over your FME workflows? If so, you’re in the right place.
Join us for an insightful dive into the world of FME parameters, a critical element in optimizing workflow efficiency. This webinar marks the beginning of our three-part “Essentials of Automation” series. This first webinar is designed to equip you with the knowledge and skills to utilize parameters effectively: enhancing the flexibility, maintainability, and user control of your FME projects.
Here’s what you’ll gain:
- Essentials of FME Parameters: Understand the pivotal role of parameters, including Reader/Writer, Transformer, User, and FME Flow categories. Discover how they are the key to unlocking automation and optimization within your workflows.
- Practical Applications in FME Form: Delve into key user parameter types including choice, connections, and file URLs. Allow users to control how a workflow runs, making your workflows more reusable. Learn to import values and deliver the best user experience for your workflows while enhancing accuracy.
- Optimization Strategies in FME Flow: Explore the creation and strategic deployment of parameters in FME Flow, including the use of deployment and geometry parameters, to maximize workflow efficiency.
- Pro Tips for Success: Gain insights on parameterizing connections and leveraging new features like Conditional Visibility for clarity and simplicity.
We’ll wrap up with a glimpse into future webinars, followed by a Q&A session to address your specific questions surrounding this topic.
Don’t miss this opportunity to elevate your FME expertise and drive your projects to new heights of efficiency.
LF Energy Webinar: Electrical Grid Modelling and Simulation Through PowSyBl -...DanBrown980551
Do you want to learn how to model and simulate an electrical network from scratch in under an hour?
Then welcome to this PowSyBl workshop, hosted by Rte, the French Transmission System Operator (TSO)!
During the webinar, you will discover the PowSyBl ecosystem as well as handle and study an electrical network through an interactive Python notebook.
PowSyBl is an open source project hosted by LF Energy, which offers a comprehensive set of features for electrical grid modelling and simulation. Among other advanced features, PowSyBl provides:
- A fully editable and extendable library for grid component modelling;
- Visualization tools to display your network;
- Grid simulation tools, such as power flows, security analyses (with or without remedial actions) and sensitivity analyses;
The framework is mostly written in Java, with a Python binding so that Python developers can access PowSyBl functionalities as well.
What you will learn during the webinar:
- For beginners: discover PowSyBl's functionalities through a quick general presentation and the notebook, without needing any expert coding skills;
- For advanced developers: master the skills to efficiently apply PowSyBl functionalities to your real-world scenarios.
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.
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.
Epistemic Interaction - tuning interfaces to provide information for AI supportAlan Dix
Paper presented at SYNERGY workshop at AVI 2024, Genoa, Italy. 3rd June 2024
https://alandix.com/academic/papers/synergy2024-epistemic/
As machine learning integrates deeper into human-computer interactions, the concept of epistemic interaction emerges, aiming to refine these interactions to enhance system adaptability. This approach encourages minor, intentional adjustments in user behaviour to enrich the data available for system learning. This paper introduces epistemic interaction within the context of human-system communication, illustrating how deliberate interaction design can improve system understanding and adaptation. Through concrete examples, we demonstrate the potential of epistemic interaction to significantly advance human-computer interaction by leveraging intuitive human communication strategies to inform system design and functionality, offering a novel pathway for enriching user-system engagements.
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.
1. 60 Minutes: An hour with Janus
Lorenzo Miniero
ClueCon – Chicago, IL, USA (kinda!)
August 4th 2020
2. Who am I?
Lorenzo Miniero
• Ph.D @ UniNA
• Chairman @ Meetecho
• Main author of Janus®
Contacts and info
• lorenzo@meetecho.com
• https://twitter.com/elminiero
• https://www.slideshare.net/LorenzoMiniero
• https://soundcloud.com/lminiero
3. Just a few words on Meetecho
• Co-founded in 2009 as an academic spin-off
• University research efforts brought to the market
• Completely independent from the University
• Focus on real-time multimedia applications
• Strong perspective on standardization and open source
• Several activities
• Consulting services
• Commercial support and Janus licenses
• Streaming of live events (IETF, ACM, etc.)
• Proudly brewed in sunny Napoli, Italy
14. What’s Janus?
Janus
General purpose, open source WebRTC server
• https://github.com/meetecho/janus-gateway
• Demos and documentation: https://janus.conf.meetecho.com
• Community: https://groups.google.com/forum/#!forum/meetecho-janus
17. Modular architecture
• The core only implements the WebRTC stack
• JSEP/SDP, ICE, DTLS-SRTP, Data Channels, Simulcast, VP9-SVC, ...
• Plugins expose Janus API over different “transports”
• Currently HTTP / WebSockets / RabbitMQ / Unix Sockets / MQTT / Nanomsg
• “Application” logic implemented in plugins too
• Users attach to plugins via the Janus core
• The core handles the WebRTC stuff
• Plugins route/manipulate the media/data
• Plugins can be combined on client side as “bricks”
• Video SFU, Audio MCU, SIP gatewaying, broadcasting, etc.
18. Modular architecture
• The core only implements the WebRTC stack
• JSEP/SDP, ICE, DTLS-SRTP, Data Channels, Simulcast, VP9-SVC, ...
• Plugins expose Janus API over different “transports”
• Currently HTTP / WebSockets / RabbitMQ / Unix Sockets / MQTT / Nanomsg
• “Application” logic implemented in plugins too
• Users attach to plugins via the Janus core
• The core handles the WebRTC stuff
• Plugins route/manipulate the media/data
• Plugins can be combined on client side as “bricks”
• Video SFU, Audio MCU, SIP gatewaying, broadcasting, etc.
19. Modular architecture
• The core only implements the WebRTC stack
• JSEP/SDP, ICE, DTLS-SRTP, Data Channels, Simulcast, VP9-SVC, ...
• Plugins expose Janus API over different “transports”
• Currently HTTP / WebSockets / RabbitMQ / Unix Sockets / MQTT / Nanomsg
• “Application” logic implemented in plugins too
• Users attach to plugins via the Janus core
• The core handles the WebRTC stuff
• Plugins route/manipulate the media/data
• Plugins can be combined on client side as “bricks”
• Video SFU, Audio MCU, SIP gatewaying, broadcasting, etc.
20. Modular architecture
• The core only implements the WebRTC stack
• JSEP/SDP, ICE, DTLS-SRTP, Data Channels, Simulcast, VP9-SVC, ...
• Plugins expose Janus API over different “transports”
• Currently HTTP / WebSockets / RabbitMQ / Unix Sockets / MQTT / Nanomsg
• “Application” logic implemented in plugins too
• Users attach to plugins via the Janus core
• The core handles the WebRTC stuff
• Plugins route/manipulate the media/data
• Plugins can be combined on client side as “bricks”
• Video SFU, Audio MCU, SIP gatewaying, broadcasting, etc.
21. Installing Janus
• Should be straightforward (not that different from other projects)
• Natively available in some repos (e.g., Debian, OpenSuse)
• We still recommend installing manually, though
• The repo README.md describes steps, for dependencies too, e.g.
# Install some dependencies from repo
apt-get install <dependencies>
# Install other dependencies manually (e.g., libnice, libsrtp, usrsctp)
# Configure and install Janus
./autogen
./configure --prefix=/opt/janus --enable-post-processing ...
make
make install
# If you need sample configuration files
make configs
22. Installing Janus
• Should be straightforward (not that different from other projects)
• Natively available in some repos (e.g., Debian, OpenSuse)
• We still recommend installing manually, though
• The repo README.md describes steps, for dependencies too, e.g.
# Install some dependencies from repo
apt-get install <dependencies>
# Install other dependencies manually (e.g., libnice, libsrtp, usrsctp)
# Configure and install Janus
./autogen
./configure --prefix=/opt/janus --enable-post-processing ...
make
make install
# If you need sample configuration files
make configs
23. Installing Janus
• Should be straightforward (not that different from other projects)
• Natively available in some repos (e.g., Debian, OpenSuse)
• We still recommend installing manually, though
• The repo README.md describes steps, for dependencies too, e.g.
# Install some dependencies from repo
apt-get install <dependencies>
# Install other dependencies manually (e.g., libnice, libsrtp, usrsctp)
# Configure and install Janus
./autogen
./configure --prefix=/opt/janus --enable-post-processing ...
make
make install
# If you need sample configuration files
make configs
24. Configuring Janus
• Janus and plugins can be configured via .jcfg files (libconfig format)
• Old INI format (.cfg) still supported, but it’s deprecated
• Some (core-only) properties can be set via command-line as well
• Format of libconfig files is quite simple to understand and use
# This is a comment
name0 = value0
category1: {
name1 = number
name2 = "string"
name3 = boolean
...
}
category2: {
name2 = [ array ]
...
}
25. Configuring Janus
• Janus and plugins can be configured via .jcfg files (libconfig format)
• Old INI format (.cfg) still supported, but it’s deprecated
• Some (core-only) properties can be set via command-line as well
• Format of libconfig files is quite simple to understand and use
# This is a comment
name0 = value0
category1: {
name1 = number
name2 = "string"
name3 = boolean
...
}
category2: {
name2 = [ array ]
...
}
26. Configuring Janus
• Janus and plugins can be configured via .jcfg files (libconfig format)
• Old INI format (.cfg) still supported, but it’s deprecated
• Some (core-only) properties can be set via command-line as well
• Format of libconfig files is quite simple to understand and use
# This is a comment
name0 = value0
category1: {
name1 = number
name2 = "string"
name3 = boolean
...
}
category2: {
name2 = [ array ]
...
}
28. A ton of scenarios done today with Janus!
• SIP and RTSP gatewaying
• WebRTC-based call/contact centers
• Conferencing & collaboration
• E-learning & webinars
• Cloud platforms
• Media production
• Broadcasting & Gaming
• Identity verification
• Internet of Things
• Augmented/Virtual Reality
• ...and more!
29. How do you talk to Janus?
https://janus.conf.meetecho.com/docs/rest
30. How do you talk to Janus?
https://janus.conf.meetecho.com/docs/rest
72. We just used it A LOT for Virtual IETF 108!
https://commcon.xyz/session/turning-live-events-to-virtual-with-janus
73. Anything wrong? Check the Admin API first!
• One option is the requests/response API to interrogate Janus
• Query server capabilities
• Control some aspects (e.g., enable/disable debugging)
• Inspect handles and WebRTC “internals”
https://www.meetecho.com/blog/understanding-the-janus-admin-api/
78. Admin API features: capturing traffic
https://www.meetecho.com/blog/capturing-webrtc-traffic-in-janus/
79. An asynchronous approach
• Admin API is cool, but is request/response...
• Needs constant polling, and data is unavailable after the session ends
• What about an asynchronous approach?
• A new mechanism: Event Handlers
• Core and plugins generate events
• Custom modules can subscribe to and handle them
• e.g., save to DB, send to external service, CDR, etc.
• Multiple handlers available out of the box
• HTTP, WebSockets, RabbitMQ, MQTT, Nanomsg
80. An asynchronous approach
• Admin API is cool, but is request/response...
• Needs constant polling, and data is unavailable after the session ends
• What about an asynchronous approach?
• A new mechanism: Event Handlers
• Core and plugins generate events
• Custom modules can subscribe to and handle them
• e.g., save to DB, send to external service, CDR, etc.
• Multiple handlers available out of the box
• HTTP, WebSockets, RabbitMQ, MQTT, Nanomsg
81. An asynchronous approach
• Admin API is cool, but is request/response...
• Needs constant polling, and data is unavailable after the session ends
• What about an asynchronous approach?
• A new mechanism: Event Handlers
• Core and plugins generate events
• Custom modules can subscribe to and handle them
• e.g., save to DB, send to external service, CDR, etc.
• Multiple handlers available out of the box
• HTTP, WebSockets, RabbitMQ, MQTT, Nanomsg
83. Type of events
• Different events handlers can subscribe to
• Core events (e.g., startup/shutdown)
• Session related events (e.g., session created/destroyed)
• Handle related events (e.g., handle attached/detached)
• JSEP related events (e.g., got/sent offer/answer)
• WebRTC related events (e.g., ICE/DTLS state changes)
• Media related events (e.g., stats on packets/bytes)
• Plugin-originated events (specific to the application)
• Transport-originated (specific to the transport)
• External events (originated via Admin API)
• Correlation possible on different identifiers
• Transport instances that originate specific session
• Opaque ID applications can set on handles of same “user”
• Plugin-specific identifiers (e.g., in VideoRoom)
84. Type of events
• Different events handlers can subscribe to
• Core events (e.g., startup/shutdown)
• Session related events (e.g., session created/destroyed)
• Handle related events (e.g., handle attached/detached)
• JSEP related events (e.g., got/sent offer/answer)
• WebRTC related events (e.g., ICE/DTLS state changes)
• Media related events (e.g., stats on packets/bytes)
• Plugin-originated events (specific to the application)
• Transport-originated (specific to the transport)
• External events (originated via Admin API)
• Correlation possible on different identifiers
• Transport instances that originate specific session
• Opaque ID applications can set on handles of same “user”
• Plugin-specific identifiers (e.g., in VideoRoom)
88. “Sample Event Handler”: HTTP as a notifier
• Simply forwards all events as JSON to an HTTP backend
• Supports basic authentication
• Can group events (i.e., JSON array vs. multiple JSON objects)
• Implements basic retransmissions (exponential back-off)
• Does nothing more than that: logic needs to be elsewhere
• HTTP backend decides what to do with events, if anything
• Behaviour can be tweaked via Admin API calls
Need something else? Check the alternatives or write your own!
A few other event handlers also available
• Other transports (in repo), SQLite (by Mozilla)
89. “Sample Event Handler”: HTTP as a notifier
• Simply forwards all events as JSON to an HTTP backend
• Supports basic authentication
• Can group events (i.e., JSON array vs. multiple JSON objects)
• Implements basic retransmissions (exponential back-off)
• Does nothing more than that: logic needs to be elsewhere
• HTTP backend decides what to do with events, if anything
• Behaviour can be tweaked via Admin API calls
Need something else? Check the alternatives or write your own!
A few other event handlers also available
• Other transports (in repo), SQLite (by Mozilla)
90. “Sample Event Handler”: HTTP as a notifier
• Simply forwards all events as JSON to an HTTP backend
• Supports basic authentication
• Can group events (i.e., JSON array vs. multiple JSON objects)
• Implements basic retransmissions (exponential back-off)
• Does nothing more than that: logic needs to be elsewhere
• HTTP backend decides what to do with events, if anything
• Behaviour can be tweaked via Admin API calls
Need something else? Check the alternatives or write your own!
A few other event handlers also available
• Other transports (in repo), SQLite (by Mozilla)
93. How can you handle events?
• Generating events is easy, evaluating them is another matter...
• Event Handlers typically just relay events, and don’t do processing themselves
• Analyzing and correlating tons of events is complicated
• A few different approaches, from easiest to trickiest
1 https://github.com/stirlab/janus-event-server (dumping events to file)
2 https://github.com/mozilla/janus-eventhandler-sqlite (dumping events to SQLite)
3 Write your own backend, e.g.,
https://www.meetecho.com/blog/event-handlers-a-practical-example/
https://www.meetecho.com/blog/correlating-janus-event-handlers/
• A much better approach: trust the smart guys!
• https://github.com/sipcapture/homer
• https://hepic.tel/
94. How can you handle events?
• Generating events is easy, evaluating them is another matter...
• Event Handlers typically just relay events, and don’t do processing themselves
• Analyzing and correlating tons of events is complicated
• A few different approaches, from easiest to trickiest
1 https://github.com/stirlab/janus-event-server (dumping events to file)
2 https://github.com/mozilla/janus-eventhandler-sqlite (dumping events to SQLite)
3 Write your own backend, e.g.,
https://www.meetecho.com/blog/event-handlers-a-practical-example/
https://www.meetecho.com/blog/correlating-janus-event-handlers/
• A much better approach: trust the smart guys!
• https://github.com/sipcapture/homer
• https://hepic.tel/
95. How can you handle events?
• Generating events is easy, evaluating them is another matter...
• Event Handlers typically just relay events, and don’t do processing themselves
• Analyzing and correlating tons of events is complicated
• A few different approaches, from easiest to trickiest
1 https://github.com/stirlab/janus-event-server (dumping events to file)
2 https://github.com/mozilla/janus-eventhandler-sqlite (dumping events to SQLite)
3 Write your own backend, e.g.,
https://www.meetecho.com/blog/event-handlers-a-practical-example/
https://www.meetecho.com/blog/correlating-janus-event-handlers/
• A much better approach: trust the smart guys!
• https://github.com/sipcapture/homer
• https://hepic.tel/
99. Writing your own plugin in C (1)
• Plugin initialization and information
• init(): called when plugin is loaded
• destroy(): called when Janus is shutting down
• get_api_compatibility(): must return JANUS_PLUGIN_API_VERSION
• get_version(): numeric version identifier (e.g., 3)
• get_version_string(): verbose version identifier (e.g., “v1.0.1”)
• get_description(): verbose description of the plugin (e.g., “This is my awesome plugin
that does this and that”)
• get_name(): short display name for your plugin (e.g., “My Awesome Plugin”)
• get_author(): author of the plugin (e.g., “Meetecho s.r.l.”)
• get_package(): unique package identifier for your plugin (e.g., “janus.plugin.myplugin”)
100. Writing your own plugin in C (2)
• Sessions management (callbacks invoked by the core)
• create_session(): a user (session+handle) just attached to the plugin
• handle_message(): incoming message/request (with or without a JSEP/SDP)
• handle_admin_message(): incoming message/request from Admin API
• setup_media(): PeerConnection is now ready to be used
• incoming_rtp(): incoming RTP packet
• incoming_rtcp(): incoming RTCP message
• incoming_data(): incoming DataChannel message
• slow_link(): notification of problems on media path
• hangup_media(): PeerConnection has been closed (e.g., DTLS alert)
• query_session(): called to get plugin-specific info on a user session
• destroy_session(): existing user gone (handle detached)
101. Writing your own plugin in C (3)
• Interaction with the core (methods invoked by the plugin)
• push_event(): send the user a JSON message/event (with or without a JSEP/SDP)
• relay_rtp(): send/relay the user an RTP packet
• relay_rtcp(): send/relay the user an RTCP message
• relay_data(): send/relay the user a DataChannel message
• close_pc(): close the user’s PeerConnection
• end_session(): close a user session (force-detach core handle)
• events_is_enabled(): check whether the event handlers mechanism is enabled
• notify_event(): notify an event to the registered and subscribed event handlers
102. Beyond C: plugins in Lua or JavaScript
https://janus.conf.meetecho.com/docs/lua
https://janus.conf.meetecho.com/docs/duktape
107. Writing your own event handler in C (1)
• Plugin initialization and information
• init(): called when event handler is loaded
• destroy(): called when Janus is shutting down
• get_api_compatibility(): must return JANUS_EVENTHANDLER_API_VERSION
• get_version(): numeric version identifier (e.g., 3)
• get_version_string(): verbose version identifier (e.g., “v1.0.1”)
• get_description(): verbose description of the plugin (e.g., “This is my awesome event
handler that does this and that”)
• get_name(): short display name for your plugin (e.g., “My Awesome Event Handler”)
• get_author(): author of the plugin (e.g., “Meetecho s.r.l.”)
• get_package(): unique package identifier for your plugin (e.g.,
“janus.eventhandler.myhandler”)
108. Writing your own event handler in C (2)
• Events management (callbacks invoked by the core)
• incoming_event(): incoming event to manage (queue and process in your thread)
• handle_request(): incoming request from Admin API to tweak the plugin
109. Thanks! Questions? Comments?
Get in touch!
• https://twitter.com/elminiero
• https://twitter.com/meetecho
• https://www.meetecho.com
