<?xml version='1.0' encoding='utf-8' ?>
<!-- Made with love by pretalx v2026.3.0.dev0. -->
<schedule>
    <generator name="pretalx" system="cfp.robocon.io" version="2026.3.0.dev0" />
    <version>0.21</version>
    <conference>
        <title>RoboCon 2023 On-line</title>
        <acronym>robocon-2023-online</acronym>
        <start>2023-02-28</start>
        <end>2023-03-03</end>
        <days>4</days>
        <timeslot_duration>00:05</timeslot_duration>
        <base_url>https://cfp.robocon.io</base_url>
        <logo>https://cfp.robocon.io/media/robocon-2023-online/img/RBCN-ONLINE-LOGO_1tJxewE.svg</logo>
        <time_zone_name>UTC</time_zone_name>
        
        
    </conference>
    <day index='1' date='2023-02-28' start='2023-02-28T04:00:00+00:00' end='2023-03-01T03:59:00+00:00'>
        
    </day>
    <day index='2' date='2023-03-01' start='2023-03-01T04:00:00+00:00' end='2023-03-02T03:59:00+00:00'>
        <room name='Gather Town' guid='4cdb8ebc-28e9-549b-8ca5-9681275e3b03'>
            <event guid='afd7e706-af28-5258-9f41-a1dc585cae12' id='28557' code='GFQVRD'>
                <room>Gather Town</room>
                <title>RoboCon Opening / Robot Framework Foundation</title>
                <subtitle></subtitle>
                <type>Keynote</type>
                <date>2023-03-01T09:00:00+00:00</date>
                <start>09:00</start>
                <duration>00:30</duration>
                <abstract>Joe will talk with Miikka and Ren&#233; about RoboCon and Robot Framework Foundation</abstract>
                <slug>robocon-2023-online-28557-robocon-opening-robot-framework-foundation</slug>
                <track></track>
                
                <persons>
                    <person id='29137'>Ren&#233; Rohner</person><person id='33038'>Miikka Solmela</person><person id='33039'>Joe Colantonio</person>
                </persons>
                <language>en</language>
                <description>In this opening session Joe Colantonio will do the housekeeping and explain a bit the conference concepts.
He will also talk with Miikka (Executive Director of Robot Framework) and Ren&#233; (Chairman of the Board of Robot Framework) about the Robot Framework Foundation and the RoboCon. You may ask questions as well.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.robocon.io/robocon-2023-online/talk/GFQVRD/</url>
                <feedback_url>https://cfp.robocon.io/robocon-2023-online/talk/GFQVRD/feedback/</feedback_url>
            </event>
            <event guid='f29033f8-d6f9-55e1-ac21-a747eb2208a9' id='24822' code='CKHB9J'>
                <room>Gather Town</room>
                <title>Welcome to RoboCon 2023</title>
                <subtitle></subtitle>
                <type>Keynote</type>
                <date>2023-03-01T09:30:00+00:00</date>
                <start>09:30</start>
                <duration>00:30</duration>
                <abstract>A Retrospective over the last year of Robot Framework and its Community.</abstract>
                <slug>robocon-2023-online-24822-welcome-to-robocon-2023</slug>
                <track></track>
                
                <persons>
                    <person id='31068'>Ed Manlove</person><person id='31067'>Pekka Kl&#228;rck</person>
                </persons>
                <language>en</language>
                <description>In this keynote Pekka will give a run through of the new features within Robot Framework 6.0 and beyond. Finally Ed will talk about the status of our awesome community and the role everyone can play. MMMM</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links>
                    <link href="https://robocon.io/?loc=U2FsdGVkX1+U66R04atE6pxOxdZ1P0ypdT78CqZ8+0Y=">robocon.io</link>
                </links>
                <attachments></attachments>

                <url>https://cfp.robocon.io/robocon-2023-online/talk/CKHB9J/</url>
                <feedback_url>https://cfp.robocon.io/robocon-2023-online/talk/CKHB9J/feedback/</feedback_url>
            </event>
            <event guid='bdfb03a0-f5c5-59ff-9f1a-ce05c2cc7dce' id='24818' code='MTRCMK'>
                <room>Gather Town</room>
                <title>What&apos;s different between RPA and test automation</title>
                <subtitle></subtitle>
                <type>Pre-Recorded Full Talk</type>
                <date>2023-03-01T10:30:00+00:00</date>
                <start>10:30</start>
                <duration>00:30</duration>
                <abstract>Test automation tools like Robot Framework have found new use cases in the domain of RPA, which is well suited for many functionalities in them. There is much involved in RPA operations, and &quot;building the robot workflow&quot; is often just the tip of the iceberg. In this talk, we drill into the key differences, what lies beyond the &quot;robot&quot;.</abstract>
                <slug>robocon-2023-online-24818-what-s-different-between-rpa-and-test-automation</slug>
                <track></track>
                
                <persons>
                    <person id='29310'>Erno Pirinen</person>
                </persons>
                <language>en</language>
                <description>&quot;Test automation tools like Robot Framework have found new use cases in the domain of RPA, which is well suited for many functionalities in them. However, there are some significant differences between the paradigms, which causes the test automation tools to perform sub-optimally due to missing features or promoting straight-up anti-patterns.

When building their first RPA use cases with test automation stack, developers often start to encounter pain points and questions like:
* I ran these 10000 customer records in an Excel, and 2892 failed. How do I retry only the failed ones?
* Finance team wants to run their robots and fix data exceptions by themselves. How do I enable that?
* The input data arrives via REST API from another system. How do I get that to robots?
* The workload is too much for one machine. How do I scale robot execution over multiple machines for efficiency? 
* Due to security / compliance requirements, I need to...
There is much involved in RPA operations, and &quot;&quot;building the robot workflow&quot;&quot; is often just the tip of the iceberg. In this talk, we drill into the key differences, what lies beyond the &quot;&quot;robot&quot;&quot;, and what kind of solutions are needed to address them. 

We will also demo the Control Room, including the work item system, which is designed from the ground-up to enable data storage, integrations, exception handling, and dynamic scaling of execution environments for building robust and efficient RPA that takes full benefit of open-source code and cloud scaling.&quot;</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.robocon.io/robocon-2023-online/talk/MTRCMK/</url>
                <feedback_url>https://cfp.robocon.io/robocon-2023-online/talk/MTRCMK/feedback/</feedback_url>
            </event>
            <event guid='8203bc8b-27ab-505b-8d72-fc52539ca18c' id='24817' code='AULYMA'>
                <room>Gather Town</room>
                <title>How workflow engines integrate manual and automated test cases</title>
                <subtitle></subtitle>
                <type>Pre-Recorded Full Talk</type>
                <date>2023-03-01T11:00:00+00:00</date>
                <start>11:00</start>
                <duration>00:30</duration>
                <abstract>In non-automated test projects everything is manual - even test data generation. But automated and manual tests like require generated test data. With a Camunda workflow engine we managed to created processes providing test data for target systems and make the transition from manual to automated tests even easier.</abstract>
                <slug>robocon-2023-online-24817-how-workflow-engines-integrate-manual-and-automated-test-cases</slug>
                <track></track>
                
                <persons>
                    <person id='30193'>Markus Stahl</person>
                </persons>
                <language>en</language>
                <description>&quot;This is currently a POC moving in to production. In a few weeks I will have some sort of lessons-learned and recommendation to demonstrate.

Our project is a fully manually tested project. Even worse, creating test data is a very very long process going through 3rd party UIs. Automating test data generation was only the first step. With workflow engine, we gain the flexibility to generate data for several SUTs and provide it dynamically to manual and automated test executions.

With this approach we are able to seemslessly automate 1 manual test after another.&quot;</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.robocon.io/robocon-2023-online/talk/AULYMA/</url>
                <feedback_url>https://cfp.robocon.io/robocon-2023-online/talk/AULYMA/feedback/</feedback_url>
            </event>
            <event guid='4e7510f1-e982-54a1-b306-159df0fa1b5f' id='23984' code='X9CQEZ'>
                <room>Gather Town</room>
                <title>Printing Robots</title>
                <subtitle></subtitle>
                <type>Pre-Recorded Full Talk</type>
                <date>2023-03-01T12:00:00+00:00</date>
                <start>12:00</start>
                <duration>00:30</duration>
                <abstract>Heidelberger Druckmachinen is world&apos;s leading manufacturer of printing presses and printshop software. My team is leading the effort to introduce Robot Framework to the test automation of the printshop universe, and you&apos;ll learn about our journey, challenges and hopes for the future.</abstract>
                <slug>robocon-2023-online-23984-printing-robots</slug>
                <track></track>
                
                <persons>
                    <person id='28250'>Adam Hepner</person>
                </persons>
                <language>en</language>
                <description>The humble printer is a very needed piece of equipment. But we all know how it sometimes misbehaves. Now imagine having a whole factory-sized floor full of various printing presses, printing 24x7, pushing hundreds of paper sheets per day, where each minute spent on troubleshooting failing process is a minute wasted. Welcome to our world.

Printing industry is very complicated and poses interesting challenges for test automation. The number of customers - printshops - is limited, but every one of them is distinct, and to push forward in ever accelerating manner, while maintaining backwards compatibility is challenging, to say the least.

Our customer - Heidelberger Druckmachinen AG - is industry leader, but that does not mean that the past few years had been easy. A lot of people who had literally invented modern printshop workflows and software are already nearing retirement. The system had been continuously evolving for past 20+ years, and the technology behind it is certainly market-tested - but bugs occur nevertheless. Domain complexity leads to test automation being more difficult that it is necessary, and team members tend to specialize in very narrow fields, despite best intentions.

Changes in market and customers&apos; expectations had also driven the company to embrace digital transformation, and now there are multiple initiatives taking place in the cloud. There are myriads of configurations and interfaces to cover with automation: on premise, in the cloud and hybrid, local and distributed, desktop UI, API and Web UI, Windows and MacOS. And the release cycle accelerates, with hopes for achieving continuous deployment for cloud components.

My team started test execution and automation at the beginning of 2020. We faced many challenges along the way, but we have also learned much. Growing a team from a single person to 8 (and counting), doing increasing amounts of manual testing while researching ways to automate as much as possible - this was certainly an exercise in humility. In the end it paid off. We are finally at the stage where it is easier to automate a new test case than not to do it.

During this talk you will learn:

- how my team organized work around manual test cycles to fit in the automation effort
- how management approval played key role in enabling our efforts, and what helped us gain traction
- where we introduce the Robot Framework tests first, why, and how it backfired
- how we integrated 3rd party tools with Robot Framework
- which libraries enabled us to reach most impressive results
- the wins, including reduction in test execution time from 7h to 1,5h
- how we approach quality regarding our own work, in order to make it easier for other contributors to work with test automation code
- what challenges lay still ahead of us, and what ideas do we have to approach them

This will be a ride through seemingly mundane world of printing - but I can promise you, it will be anything but boring.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.robocon.io/robocon-2023-online/talk/X9CQEZ/</url>
                <feedback_url>https://cfp.robocon.io/robocon-2023-online/talk/X9CQEZ/feedback/</feedback_url>
            </event>
            <event guid='b3ab0081-f107-54ff-9a52-981c0e40bf3e' id='23028' code='N3QCPT'>
                <room>Gather Town</room>
                <title>Know your Robot</title>
                <subtitle></subtitle>
                <type>Pre-Recorded Full Talk</type>
                <date>2023-03-01T12:30:00+00:00</date>
                <start>12:30</start>
                <duration>00:30</duration>
                <abstract>Knowing our own Robot Framework codebase helps to keep the code clean, from which a long-term development can always benefit. This talk is about how we visualise and enable the analysis of the dependencies of keywords, test cases, and test suites in keyword-driven tests, so the keywords can be used and refactored more efficiently.</abstract>
                <slug>robocon-2023-online-23028-know-your-robot</slug>
                <track></track>
                
                <persons>
                    <person id='28110'>Liya Ou</person>
                </persons>
                <language>en</language>
                <description>Have you been struggling with the massive keywords with the growing number of tests?  Do you want to avoid reinventing the wheel? Does that sound familiar with your frequently failing automated tests that never find a bug? 

Test automation is more helpful when it supports the team with faster feedback and frees up the time for investing in other opportunities. As the codebase of keyword-driven testing grows continuously during the development of the test plans, ideally, created keywords can be reused and the time to script a new test case can be reduced. However, lacking an overview of the keywords may lead to the creation of duplicate keywords, a longer time to investigate when a bug occurs, or even changes that make some tests fail. If investing in automation creates more problems to solve with no real value add, then it is a sheer waste of resources.  

Our practice is built on keyword-driven testing with Robot Framework, scans the test scripts, reveals the hierarchies of keywords, test cases, and test suites in tree views, enables high reusability of automated tests, and makes reviewing and debugging way easier.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.robocon.io/robocon-2023-online/talk/N3QCPT/</url>
                <feedback_url>https://cfp.robocon.io/robocon-2023-online/talk/N3QCPT/feedback/</feedback_url>
            </event>
            <event guid='335fd384-7514-5b39-bcbd-8bbd972cf045' id='22750' code='JAXTEX'>
                <room>Gather Town</room>
                <title>RCC - Take control of your Robot Framework runs</title>
                <subtitle></subtitle>
                <type>Pre-Recorded Full Talk</type>
                <date>2023-03-01T14:00:00+00:00</date>
                <start>14:00</start>
                <duration>00:30</duration>
                <abstract>No matter what type of developer you are, you have faced the problem of &quot;Works on my machine&quot;.
How many things do you have to guide in setting up a machine to run a robot?
RCC is a single cross-platform executable to manage all this... and significantly more.
&quot;If your README starts with &apos;pip install abc&apos;, then this talk is for you.&quot;</abstract>
                <slug>robocon-2023-online-22750-rcc-take-control-of-your-robot-framework-runs</slug>
                <track></track>
                
                <persons>
                    <person id='28524'>Kari Harju</person>
                </persons>
                <language>en</language>
                <description>Ask yourself:
Does the README in your project root actually cover getting a new developer up and running?
How often have you heard: &quot;Works on my machine&quot;?
How long does it take for you to get your robot running on another machine?
How sure are you that the last run of the robot did not change something?

When developing with RobotFramework, you cannot avoid these common topics, just like in any software development. Usually, these tend to get brushed under the rug as &quot;this is only a one-time setup&quot;, but in the real world, it is not the case. You will need to switch between projects requiring different Python versions, a specific Firefox version, etc. ...and that is the simplest case.

Getting a repeatable, movable, clean environment for your robot execution is a big thing. In RPA, this is crucial, but this should also be the base mindset in test automation. No matter the case you want to be sure that when you run the same thing repeatedly, your foundation does not change.
RCC toolchain is not just for RPA; it is more than Python or RobotFramework, basically &quot;it is not just for X&quot;. RCC enables you to define, package, and isolate your robot project and the dependencies your robot needs. But RCC does a LOT more than that.

Let&apos;s see how many things I can cover in this talk, but the hook is:
&quot;If your README starts with &apos;pip install abc&apos;, then this talk is for you.&quot;

&lt;a href=&quot;https://github.com/robocorp/rcc&quot;&gt;github.com/robocorp/rcc&lt;/a&gt;</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.robocon.io/robocon-2023-online/talk/JAXTEX/</url>
                <feedback_url>https://cfp.robocon.io/robocon-2023-online/talk/JAXTEX/feedback/</feedback_url>
            </event>
            <event guid='2b703b58-bffb-55e5-8c49-7ecf0524df7f' id='22859' code='DRXANT'>
                <room>Gather Town</room>
                <title>Our way to visual RF coding</title>
                <subtitle></subtitle>
                <type>Pre-Recorded Full Talk</type>
                <date>2023-03-01T14:30:00+00:00</date>
                <start>14:30</start>
                <duration>00:30</duration>
                <abstract>RF is awesome and easy to use framework. But still, it requires certain knowledge of coding and python programming which makes it not usable for our beloved manual testers and business analysts. But there might be a solution for that!</abstract>
                <slug>robocon-2023-online-22859-our-way-to-visual-rf-coding</slug>
                <track></track>
                
                <persons>
                    <person id='27895'>David Fogl</person>
                </persons>
                <language>en</language>
                <description>We are building an universal visual-coding application (collaborative Web IDE) for Robot Framework which you were able to spot last Robocon22 during the Workshops. We have used the time in between to make our application easier to use, finished the main features and introduced a completely new system that allows the users to use any RF/Python library that can be downloaded from PIP. In our talk, I would like to take you on the road which lead us to the initial idea of Visual-code RF IDE, what was our thought process why even making it and explain why we believe it might help the growing number of RF users. 
&lt;/p&gt;
Engaging manual testers in automation is an interesting task. On many of our projects we see, that smaller companies have difficulty starting with automation testing and eventually they end up either with self-developed frameworks or tools that record user clicks and create unmaintainable playable automation. We would like to help these companies and show them how easy it can be to create automation test, how easy is to run the RF automation in cloud environment without the need to install anything on your environment. We believe writing comprehensive automation should not be difficult, it should be accessible to all the users.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.robocon.io/robocon-2023-online/talk/DRXANT/</url>
                <feedback_url>https://cfp.robocon.io/robocon-2023-online/talk/DRXANT/feedback/</feedback_url>
            </event>
            <event guid='f846179d-91c2-5694-b5a9-f254311b5760' id='23147' code='MGCBMF'>
                <room>Gather Town</room>
                <title>Ninja robots</title>
                <subtitle></subtitle>
                <type>Pre-Recorded Full Talk</type>
                <date>2023-03-01T15:30:00+00:00</date>
                <start>15:30</start>
                <duration>00:30</duration>
                <abstract>In my experience as a solo user with limited to no access to reviews, these tools and techniques allowed me to be successful, with purpose build keyword libraries

1.git, especially git bisect and log -S

2.advanced unit testing with pytest, xray, and hypothesis

3.measurable complexity with radon

4.Therefore orthogonally structured code</abstract>
                <slug>robocon-2023-online-23147-ninja-robots</slug>
                <track></track>
                
                <persons>
                    <person id='28221'>franz haas</person>
                </persons>
                <language>en</language>
                <description>## Ninja robots

I would like to discuss the possibility to substitute review with tools. Reviews are the better solution, this is to be used if for some reason reviews are not available.

### Learn about the history of your code base.

&quot;git bisect&quot; plus &quot;git log -S&quot; is an efficient way to properly blame. Especially in a corporate environment, people tend to copy code and claim credit until it&apos;s a problem.
Using git log -S it is possible to find the earliest occurrence of a piece of code. This is especially useful with function names. This is a static code analysis approach 
to explore a code base.

This may not give enough insight tough. Using git bisect it is possible to find the change that changed the result of a test from pass to fail or vice versa.
This is especially useful in situations in which a bugfix, creates another bug. This fulfills a similar purpose as log -S but experimentally.

This has advantages over communications as it brings hard facts, while it is easy to talk up a theory in a small group.

I would run through examples of both techniques using an open-source project as an example. Preferably robotframework itself, but I do not have an endorsement yet. 
We will have a look at when a specific function was introduced, and how its popularity developed over time.

### Measure whether your tests detect changes in your code base.

The theory is that given correct code that has at some place a &quot;+&quot;, is very likely to become bugy when the &quot;+&quot; is replaced with an &quot;%&quot; for example.
This detects among other things, dead code, gaps in the test coverage, and vague specifications.

## Ask the computer to check for the limits of an implementation
Does your function work with negative numbers? 0? Are there size limitations? using hypothesis it is easy to learn about these limits and ask a computer to check those limits.

### Without a corrective it is easy to think that code is more elegant and easy to understand than it is.

By using radon it is possible to use the computer to provide objective feedback about the complexity of source code.

finally, we will see that points 2 and 3 are interconnected, and lead to 

### orthogonal structures
which means that functionality is created by composing simple building blocks, as opposed to inheritance, code injection, etc ...</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.robocon.io/robocon-2023-online/talk/MGCBMF/</url>
                <feedback_url>https://cfp.robocon.io/robocon-2023-online/talk/MGCBMF/feedback/</feedback_url>
            </event>
            <event guid='50f459e7-826f-5a62-b595-2ebc3abca1df' id='24823' code='SAMETK'>
                <room>Gather Town</room>
                <title>Robot Framework and endpoint detection agents at Secureworks</title>
                <subtitle></subtitle>
                <type>Pre-Recorded Full Talk</type>
                <date>2023-03-01T16:00:00+00:00</date>
                <start>16:00</start>
                <duration>00:30</duration>
                <abstract>This talk will cover various high-level ways that Robot Framework is utilized at Secureworks for testing endpoint detection agents used on thousands of Linux, Mac and Windows customer&apos;s machines.</abstract>
                <slug>robocon-2023-online-24823-robot-framework-and-endpoint-detection-agents-at-secureworks</slug>
                <track></track>
                
                <persons>
                    <person id='30196'>Joshua Gorospe</person>
                </persons>
                <language>en</language>
                <description>&quot;The world has many cybersecurity threat actors that will use any tool at their disposal to expose and monopolize potential security vulnerabilities. At Secureworks, we keep an open-mind about learning the latest adversary tactics, and seamlessly switching context to experiment with new bleeding edge detection techniques. For the past 2.5 years I have proven to my team that Robot Framework is the ideal QA swiss-army-tool to match the context switching that is required to build high-quality XDR products.

In this talk I will give a high-level overview of how the Secureworks Agent QA Team uses Robot Framework for various endpoint agent test strategies, such as...
- Robot Framework and Docker strategies testing endpoint agents on Virtual Machines
- Automation at scale through QA GitLab pipelines (Linux, Mac and Windows)
- Parallel running Robot Framework Gatling + Docker load test strategies 
- Torture testing an endpoint agent using Robot Framework with Chaos Testing and Model Based Testing
- Combining PaBot + Vagrant + Robot Framework DataDriver Library to dynamically automate the MITRE ATT&amp;CK Framework&quot;</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.robocon.io/robocon-2023-online/talk/SAMETK/</url>
                <feedback_url>https://cfp.robocon.io/robocon-2023-online/talk/SAMETK/feedback/</feedback_url>
            </event>
            <event guid='ee57660c-834a-5c58-a9f2-28cd5c632a3b' id='22779' code='K3EA3U'>
                <room>Gather Town</room>
                <title>You got your Robot Framework in my Python</title>
                <subtitle></subtitle>
                <type>Pre-Recorded Full Talk</type>
                <date>2023-03-01T17:00:00+00:00</date>
                <start>17:00</start>
                <duration>00:30</duration>
                <abstract>In the Robot Framework community we are so focused on adapting python packages that we can use Robot Framework libraries in standard Python scripts.</abstract>
                <slug>robocon-2023-online-22779-you-got-your-robot-framework-in-my-python</slug>
                <track></track>
                
                <persons>
                    <person id='28527'>Kelby Stine</person>
                </persons>
                <language>en</language>
                <description>There has been plenty of work adapting key Python packages to Robot Framework: Requests, XML, JSON, Selenium, to name a few. The open source community has created and hammered out respectable abstractions and boiler plate code to get them to work reliably with Robot Framework. 
Why not leverage these efforts in regular python code?
     I will present details on how Python code can integrate Robot Framework. The inherent advantages of being able to write code using them. Also the benefits of being able to quickly adapt those scripts back to Robot Framework.
     As with any use of wrapper type packages there caveats when using them, especially when it comes to managing dependencies.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.robocon.io/robocon-2023-online/talk/K3EA3U/</url>
                <feedback_url>https://cfp.robocon.io/robocon-2023-online/talk/K3EA3U/feedback/</feedback_url>
            </event>
            <event guid='51dd4297-647e-5942-bd2f-8bc44283ebec' id='24821' code='AW8NLK'>
                <room>Gather Town</room>
                <title>Edge detection - a new way to perform image-based UI testing</title>
                <subtitle></subtitle>
                <type>Pre-Recorded Full Talk</type>
                <date>2023-03-01T17:30:00+00:00</date>
                <start>17:30</start>
                <duration>00:20</duration>
                <abstract>My personal &quot;rabbit hole&quot; with image-based UI testing - and how I got back.</abstract>
                <slug>robocon-2023-online-24821-edge-detection-a-new-way-to-perform-image-based-ui-testing</slug>
                <track></track>
                
                <persons>
                    <person id='30191'>Simon Meggle</person>
                </persons>
                <language>en</language>
                <description>&quot;Image-based UI testing libraries (e.g. ImageHorizon or Sikuli) use small reference images to localize elements on the screen (e.g. buttons). 

This method works extremely well ... - well, almost. 

*&quot;&quot;Image &apos;button1.png&apos; was not found on screen&quot;&quot;.*
Do you know this message? If you still get it after 30 test runs, you want to scream at the library: &quot;&quot;Are you blind? There&apos;s the button! Click on it now, for God&apos;s sake!&quot;&quot;

In a customer project I had such errors all the time - and got to the bottom of them. 
And to be honest, I was a bit shocked how lucky I always was when I finally got a hit and the test worked - just because I had fiddled long enough with the recognition accuracy (&quot;&quot;similarity&quot;&quot;/&quot;&quot;confidence&quot;&quot; etc.) in an almost criminal way. 

With this in mind, we added a new detection strategy to the ImageHorizonLibrary which **pre-processes the images** to be searched using the **&quot;&quot;canny edge detection&quot;&quot;** algorithm. 

In the presentation, I introduce the &quot;&quot;edge&quot;&quot; strategy and use examples from real customer projects to show where it has been a real problem solver.&quot;</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.robocon.io/robocon-2023-online/talk/AW8NLK/</url>
                <feedback_url>https://cfp.robocon.io/robocon-2023-online/talk/AW8NLK/feedback/</feedback_url>
            </event>
            
        </room>
        
    </day>
    <day index='3' date='2023-03-02' start='2023-03-02T04:00:00+00:00' end='2023-03-03T03:59:00+00:00'>
        <room name='Gather Town' guid='4cdb8ebc-28e9-549b-8ca5-9681275e3b03'>
            <event guid='2f5b1537-f9ec-5104-9e98-a39faf1052a8' id='22753' code='XYAJN3'>
                <room>Gather Town</room>
                <title>Fast Feedback Despite Slow Test Suites? Test-Impact-Analysis for the Robot Framework</title>
                <subtitle></subtitle>
                <type>Pre-Recorded Full Talk</type>
                <date>2023-03-02T09:00:00+00:00</date>
                <start>09:00</start>
                <duration>00:30</duration>
                <abstract>Test suites grow over time. We see may test suites that take hours or days to execute. This is painfully slow.Test-Impact-Analysis automatically selects those tests that find new bugs quickly. This helps to get rapid feedback even for slow test suites. In the talk, I present both research foundations and practical examples for the Robot Framework.</abstract>
                <slug>robocon-2023-online-22753-fast-feedback-despite-slow-test-suites-test-impact-analysis-for-the-robot-framework</slug>
                <track></track>
                
                <persons>
                    <person id='28525'>Elmar J&#252;rgens</person>
                </persons>
                <language>en</language>
                <description>Successful software grows, and so does its test suite. Increasingly more of our customers have test suites that take several hours of even days to execute in full. However, the longer the time between the introduction of a bug during development, and its discovery through a test failure, the harder it gets to pinpoint the change that introduced this bug. The longer the test execution time, the larger the pain for all involved developers and testers.

If the execution of the _entire_ test suite takes too long, a simple solution is to _only execute a subset of the suite that require less time_. If this subset is chosen well, its execution can find the majority of the bugs very quickly. The remaining tests can then still be executed every night / week to detect the remaining bugs. This way, we achieve rapid bug discovery times for most new bugs even for large, slow test suites.

However, how well this works in practice depends on _how we select the subset_ of tests that gets executed more frequently. In recent years, we have experimented with many various selection techniques, both in research projects and together with our customers. Two work very well: Test-Impact-Analysis and Pareto-Optimization of test suites. 

In this talk, I present both approaches. I share their basic ideas and our research findings. I also present how they can be applied to the Robot Framework and give examples from the Robot Framework and our customers.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.robocon.io/robocon-2023-online/talk/XYAJN3/</url>
                <feedback_url>https://cfp.robocon.io/robocon-2023-online/talk/XYAJN3/feedback/</feedback_url>
            </event>
            <event guid='188d3bb3-e1c7-515d-8242-8d5656dd408b' id='24813' code='ZSLPJF'>
                <room>Gather Town</room>
                <title>Open-source is a multi-player game</title>
                <subtitle></subtitle>
                <type>Pre-Recorded Full Talk</type>
                <date>2023-03-02T09:30:00+00:00</date>
                <start>09:30</start>
                <duration>00:30</duration>
                <abstract>With open-source comes great responsibility. Or something like that...
Working on open-source project is fun, but also a lot of hard decisions one need to make in order to maintain it and gain the trust from the community.
This talk will bring you the best practices and tricks that will make the contribution a pleasant journey for you and others.</abstract>
                <slug>robocon-2023-online-24813-open-source-is-a-multi-player-game</slug>
                <track></track>
                
                <persons>
                    <person id='30194'>Mateusz Nojek</person>
                </persons>
                <language>en</language>
                <description>the talk will be conducted by well-known duo of Robot Framework contributors - Mateusz Nojek and Bart&#322;omiej Hirsz. Their 4 open-source RF-related projects reached over 1 million downloads and are being constantly improved with a help of the community. After several years of experience in contributing, creating and maintaining open-source projects, they are finally ready to share their best practices, tips &amp; tricks that will help the others make the world a better place... at least the open-source world ;)
After this presentation you will know:
- how to share the work between you and others
- how to communicate with the community by issues and pull requests
...</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.robocon.io/robocon-2023-online/talk/ZSLPJF/</url>
                <feedback_url>https://cfp.robocon.io/robocon-2023-online/talk/ZSLPJF/feedback/</feedback_url>
            </event>
            <event guid='e9eb9e2e-d976-5219-8aa0-746acb53f852' id='22627' code='T8KEQR'>
                <room>Gather Town</room>
                <title>How to run a large and diverse regression test in parallel on multiple servers</title>
                <subtitle></subtitle>
                <type>Pre-Recorded Full Talk</type>
                <date>2023-03-02T10:30:00+00:00</date>
                <start>10:30</start>
                <duration>00:30</duration>
                <abstract>We were faced with the challenge to run our regression test in parallel and within a night. To make the challenge harder: not all test can run in parallel. We build a Python tool that runs 24/7 on multiple servers and accepts tasks: Execute RFW test suites. A task can be ran in parallel or not. The tool (ART_Queue) takes care of that.</abstract>
                <slug>robocon-2023-online-22627-how-to-run-a-large-and-diverse-regression-test-in-parallel-on-multiple-servers</slug>
                <track></track>
                
                <persons>
                    <person id='28526'>Pieter Wesseling</person>
                </persons>
                <language>en</language>
                <description>Preface:
The grid operators in the Netherlands were migrating their system into to a system called C-ARM which is an application that centralize energy data and calculations for the processes of allocation, reconciliation and measurement data for all gas and electric metering data in the Netherlands. The client wanted to cover a large number of test requirements by automated tests, which resulted in 1000+ Robot Framework regression test cases at the time. Running these tests in a short amount of time needed to be run in parallel. The first solution was a very large number of windows batch scripts, which worked but had a major flaw: it was only maintainable by its creator. When he left the project it became clear that making changes took a lot of time. And that the whole set of batch jobs could only be used on one test environment, so a small change of the test set lead to manual code changes to multiple (batch) files.

Solution:
A new way of running the regression test set was much needed, we call this new way the ART run software. This is a Python program which reads an input file, adds some additional information and use robot commands to execute the parallel jobs and the nonparallel jobs separately. After all jobs ere finished, the run software creates test the RFW reports. The redesign resulted in fewer lines of code than there were batch files, which improved the maintainability of running the regression test. 
For the first time it was easy to run our tests. And it worked like a charm. 

Running a lot of test cases at a daily bases creates a lot of test evidence. For quite a while we exported the test results as csv files which then are merged into one Excel report. There were no complains about the Excel file, but we wanted an easier way to store the test results which made us try the rfw library Testarchiver. This library stores the rfw test results in a database of your choice. We linked the created database to a Grafana dashboard.
 
With the software running on dedicated servers, the other testers on the project were interested in using it as well. Security did not grant them access to the severs which led to the solution called &#8216;ART Queue&#8217;: replace the csv with a central database; where the csv was a static list on a server updated once a day, the queue is dynamic. Every tester can now add test jobs to the queue which are than picked up by the ART run software.  And the results of their tests can be retrieved from Grafana and a web portal.

The ART Queue software is now running 24/7 and always able to run a test.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.robocon.io/robocon-2023-online/talk/T8KEQR/</url>
                <feedback_url>https://cfp.robocon.io/robocon-2023-online/talk/T8KEQR/feedback/</feedback_url>
            </event>
            <event guid='9c157420-45df-5959-996a-70e1378b65a1' id='23281' code='HYQUWN'>
                <room>Gather Town</room>
                <title>DevSecOps as a Culture with the Robot Framework</title>
                <subtitle></subtitle>
                <type>Pre-Recorded Full Talk</type>
                <date>2023-03-02T11:00:00+00:00</date>
                <start>11:00</start>
                <duration>00:30</duration>
                <abstract>In the Work From Home culture, DevSecOps has been getting more important than ever before due to the rise in cybercrime. This talk will discuss how to implement and manage testing with the Robot Framework in projects within teams and how to create an iterative development approach as part of it.</abstract>
                <slug>robocon-2023-online-23281-devsecops-as-a-culture-with-the-robot-framework</slug>
                <track></track>
                
                <persons>
                    <person id='28251'>Renaldi Gondosubroto</person>
                </persons>
                <language>en</language>
                <description>DevSecOps, with its principle that stresses that everyone is responsible for security, has become a practice that has been more popular than ever in the Work From Home (WFH) culture. In the development of DevSecOps-related projects, testing has been an integral part of the culture. Many teams working with the agile framework have already adopted the practice, with some still transitioning to getting accustomed to the practice in comparison to the traditional DevOps approach to testing.

This talk will discuss how testing with the Robot Framework within DevSecOps contrasts with the traditional DevOps approach within the agile environment, and show how to manage testing with the framework from start to finish. This will include how to plan for testing within DevSecOps, how writing test suites with the framework differs when we want to ensure that everyone is responsible to security, feedback mechanisms in standup meetings and how to maintain the culture within testing teams. This will also include implementing and managing the culture of iterative development, which requires continuous development of test suites as needed according to updates that are made, keeping security in applications as the top priority. Finally, I will talk about how these tests can then be automated in a DevSecOps context with a Cloud provider such as, in this case, Azure.

I will support my talk with a case study regarding the testing using Robot Framework done on one of my projects. Attendees will leave the talk feeling ready to implement the DevSecOps framework on their projects, and get the most out of security with the Robot Framework by doing so. As the WFH culture is going to stay for quite some time, it is going to be quite imperative to understand the DevSecOps culture to best prepare for it.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.robocon.io/robocon-2023-online/talk/HYQUWN/</url>
                <feedback_url>https://cfp.robocon.io/robocon-2023-online/talk/HYQUWN/feedback/</feedback_url>
            </event>
            <event guid='548e9833-32ec-5604-8074-e65868bb4cdd' id='24824' code='WSBCXF'>
                <room>Gather Town</room>
                <title>The tales of the robot developers - how to make friends as a consultant</title>
                <subtitle></subtitle>
                <type>Pre-Recorded Full Talk</type>
                <date>2023-03-02T12:00:00+00:00</date>
                <start>12:00</start>
                <duration>00:30</duration>
                <abstract>As a consultant you work in very different kinds of projects; small, big, some are growing from small to big, sometimes you start from a scratch or sometimes not. In this talk we discuss strategies of making clean and manageable robot framework scripts so that everybody wants to be your friend; especially the customer and the one after you.</abstract>
                <slug>robocon-2023-online-24824-the-tales-of-the-robot-developers-how-to-make-friends-as-a-consultant</slug>
                <track></track>
                
                <persons>
                    <person id='30199'>Katarina Partti</person><person id='27822'>Jenna Lindroos</person>
                </persons>
                <language>en</language>
                <description>Katarina Partti and Jenna Lindroos are test automation consultants with experience on different kinds of projects. As a consultant you know you&apos;re probably not the first and definitely not the last to touch those automation scripts so it is very important to make it as understandable and easy as possible. This talk is about different kinds of Robot Framework projects and how to deal with them on a concrete level. We discuss about documentation, keywords etc.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.robocon.io/robocon-2023-online/talk/WSBCXF/</url>
                <feedback_url>https://cfp.robocon.io/robocon-2023-online/talk/WSBCXF/feedback/</feedback_url>
            </event>
            <event guid='9910a04c-d491-5bdb-904f-8eabbcd8eb6e' id='24027' code='HKSQYD'>
                <room>Gather Town</room>
                <title>VSCode tips and tricks for Robot Framework development</title>
                <subtitle></subtitle>
                <type>Pre-Recorded Full Talk</type>
                <date>2023-03-02T12:30:00+00:00</date>
                <start>12:30</start>
                <duration>00:30</duration>
                <abstract>This talk will go over common development scenarios for Robot Framework and how to leverage VSCode features to help with those (with the Robot Framework Language Server as the main driver but other frameworks and tools may be added to the mix).</abstract>
                <slug>robocon-2023-online-24027-vscode-tips-and-tricks-for-robot-framework-development</slug>
                <track></track>
                
                <persons>
                    <person id='29113'>Fabio Zadrozny</person>
                </persons>
                <language>en</language>
                <description>The idea is briefly skimming over some common features of the Robot Framework Language Server and then going deeper into some common scenarios, for instance, being able to interactively build a Robot while inspect the browser and extracting locators or using a TDD approach to develop Robots and even what to do when things go haywire.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.robocon.io/robocon-2023-online/talk/HKSQYD/</url>
                <feedback_url>https://cfp.robocon.io/robocon-2023-online/talk/HKSQYD/feedback/</feedback_url>
            </event>
            <event guid='d8b0bf1f-4d7c-5ed8-92cd-9b413eb16677' id='24820' code='NLM3AS'>
                <room>Gather Town</room>
                <title>Creating a low-code editor for Robot Framework</title>
                <subtitle></subtitle>
                <type>Pre-Recorded Full Talk</type>
                <date>2023-03-02T14:00:00+00:00</date>
                <start>14:00</start>
                <duration>00:30</duration>
                <abstract>While the syntax of Robot Framework is simple, it can still be daunting to approach without a technical background. We created a new low-code editor to allow non-developers to create automations. We describe the architectural decisions behind the project, and how Robot Framework itself enabled it from both a language design and code perspective.</abstract>
                <slug>robocon-2023-online-24820-creating-a-low-code-editor-for-robot-framework</slug>
                <track></track>
                
                <persons>
                    <person id='30190'>Ossi Rajuvaara</person>
                </persons>
                <language>en</language>
                <description>&quot;Robot Framework is a great automation tool that allows a low barrier to entry while maintaining a high ceiling for growth. However, coming to Robot Framework without a programming background can be daunting. While the language is relatively simple, even the concept of text-based programming presents a steep learning curve for many new users. There are also syntactical quirks to internalize, many libraries to familiarize with, and sometimes you might need to understand Python. 

The low-code movement has been rapidly growing in recent years. The term Citizen Developer has become popular to describe these non-developers who automate their day-to-day work. They&#8217;re non-technical users with lots of business domain knowledge but lack the background to use traditional programming languages or tools. While the term itself is mainly used in the world of RPA, the persona also applies to many people involved with test automation.

During Robocon 2022, we showed Automation Studio, which is a new kind of low-code tool for Robot Framework. It allows you to get started with a drag-and-drop interface and build automations without any previous experience with Robot Framework or Python. However, it also allows you to move seamlessly between visual and text-based editing and learn the basic concepts of Robot Framework without the burden of typing syntactically correct code.

In this talk, we&#8217;ll go through how we approached creating Automation Studio and what goes into designing a development tool for non-technical users. We describe the various architectural decisions we made along the way and how we leveraged the open-source community and existing projects around Robot Framework to make it happen. We will also show how Robot Framework enables the creation of such a tool from both a language design and code perspective. The project has also revealed some improvement areas for Robot Framework, which we think would benefit the entire ecosystem.&quot;</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.robocon.io/robocon-2023-online/talk/NLM3AS/</url>
                <feedback_url>https://cfp.robocon.io/robocon-2023-online/talk/NLM3AS/feedback/</feedback_url>
            </event>
            <event guid='3389e2ad-7d67-53f5-b363-f65ce4d05bd6' id='22258' code='AXBYUP'>
                <room>Gather Town</room>
                <title>Aren&apos;t your selectors too stable?</title>
                <subtitle></subtitle>
                <type>Pre-Recorded Full Talk</type>
                <date>2023-03-02T14:30:00+00:00</date>
                <start>14:30</start>
                <duration>00:30</duration>
                <abstract>Junior automation testers are taught that fragile selectors of web elements are wrong, and that stability should be their goal. Then they usually end up with their selectors being too stable. What? Is there such a thing as a too stable selector? Don&apos;t we want a selector to describe its element, come rain or shine? Long story short: we don&apos;t.</abstract>
                <slug>robocon-2023-online-22258-aren-t-your-selectors-too-stable</slug>
                <track></track>
                
                <persons>
                    <person id='28528'>V&#225;clav Fuksa</person>
                </persons>
                <language>en</language>
                <description>The design of the web elements&#8217; selectors is one of the most important design features of the front-end test automation. Although it might sound good, the maximum possible stability of selectors is not desired. The problem of a too stable selector is that it describes an element even if its substantial characteristics have changed. What are &quot;substantial characteristics&quot;? The only reasonable answer, covered in this talk, is that these are the ones determined by the scenario for the&#8239;test automation&#8212;or by a common sense when the former is missing. A short example: users/testers are used to seeing a &quot;Continue&quot; button in a certain place in an application. Then a sudden change in the application renames the &quot;Continue&quot; button to &quot;Next&quot;. Are the users/testers going to be confused? Yes, they are. And should the test handling the &quot;Continue&quot; button, which simulates users&#8217; behaviour, fail? It should&#8212;but it won&#8217;t if the button is referred as `id=cont_btn` instead of its title.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.robocon.io/robocon-2023-online/talk/AXBYUP/</url>
                <feedback_url>https://cfp.robocon.io/robocon-2023-online/talk/AXBYUP/feedback/</feedback_url>
            </event>
            <event guid='88a21b07-c035-55a2-a747-43820f84c62d' id='24815' code='XWZVHN'>
                <room>Gather Town</room>
                <title>How Painful IS It To Move From SeleniumLibrary To Browser Library?</title>
                <subtitle></subtitle>
                <type>Pre-Recorded Full Talk</type>
                <date>2023-03-02T15:30:00+00:00</date>
                <start>15:30</start>
                <duration>00:30</duration>
                <abstract>As Playwright battles for the hearts and minds of Selenium die-hards, we made the decision to see what Playwright could do. Follow along as we make the switch from a Selenium Library-based set of tests to Browser Library. Some aspects were seamless while others have proven to be far less so. And finally, what DID we get? Stop by and find out!</abstract>
                <slug>robocon-2023-online-24815-how-painful-is-it-to-move-from-seleniumlibrary-to-browser-library</slug>
                <track></track>
                
                <persons>
                    <person id='30192'>Samuel Tillinghast</person>
                </persons>
                <language>en</language>
                <description>&quot;Selenium Library has long been the go-to tool for automating web testing in Robot Framework. With the growth of Playwright as a competing tool, Browser Library, a Robot Framework library built on Playwright, has emerged as an alternative. Browser Library has been heralded as the faster-better-cheaper alternative and we wanted to see if that was true AND how hard it would be to get those benefits.

What we found is that Browser Library isn&apos;t a drop-in replacement. I will go over both the simple and the complex aspects of this conversion. 

We worked with the limitation of keeping our tests functioning with Selenium while being able to simply use a command line parameter to select the Browser Library. 

We did have the benefit of an extensive set of abstraction layers that reduced the direct usage of Selenium Library calls at the test and high-level keyword levels.
 
Simple:
- Browser Library supports a subset of the Selenium locator/selector strategies (and fortunately, we used few to none of the non-supported implementations in our original Selenium, hence this was &#8220;easy&#8221;)
- Interacting with Iframes in Selenium is significantly different than Browser Library but making that work in Browser Library, simply required adding the iframe selector to the front of the locator.
- For every Selenium Library keyword, we found very straightforward Browser Library equivalents. 

Complex:
- To support both libraries, direct calls to either library needs to be hidden in an abstraction layer utilized by the tests proper.
- Iframe interactions seem to be more stable out-of-the-box with Selenium Library.
- Existing use of other libraries that depend on Selenium will require our own implementations or convincing those teams to also support Playwright.
- We had extended some Selenium keywords which was implemented in Python. Browser Library extensions requires a working knowledge of NodeJS.
 
What did we find?
- SPEED! Over a small set of 60 smoke tests, we have seen a reduction of nearly 50% of our execution time with Browser Library.
- The current activity on the Browser Library seems to be more robust than the Selenium Library and the Slack channel support has been excellent.
- Iframe error reporting in Browser Library is decidedly lacking.&quot;

[Codebase for RoboCon 2023 talk. Tests that can run in Browser Library or SeleniumLibrary.](https://cfp.robocon.io/media/robocon-2023-online/submissions/XWZVHN/resources/robocon_code_M24JFrp_pVVyPPp.zip)</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments>
                    <attachment href="https://cfp.robocon.io/media/robocon-2023-online/submissions/XWZVHN/resources/robocon_code_M24JFrp_pVVyPPp.zip">Codebase for RoboCon 2023 talk. Tests that can run in Browser Library or SeleniumLibrary.</attachment>
                </attachments>

                <url>https://cfp.robocon.io/robocon-2023-online/talk/XWZVHN/</url>
                <feedback_url>https://cfp.robocon.io/robocon-2023-online/talk/XWZVHN/feedback/</feedback_url>
            </event>
            <event guid='d8a8463d-8c4d-5490-a554-bb2d4d7658ae' id='24816' code='ASXKLW'>
                <room>Gather Town</room>
                <title>&quot;To infinity and beyond&quot; - Serverless scaling with AWS Lambda</title>
                <subtitle></subtitle>
                <type>Pre-Recorded Full Talk</type>
                <date>2023-03-02T16:00:00+00:00</date>
                <start>16:00</start>
                <duration>00:30</duration>
                <abstract>&quot;Running automated tests in CI systems has become a common practice.
Luckily, the structure of CI systems allow us to run tests on multiple runners in parallel and reduce the execution time.
But are there ways to scale to infinity - without having an army of runners?
Say hello AWS Lambda - a serverless event-driven compute service.&quot;</abstract>
                <slug>robocon-2023-online-24816-to-infinity-and-beyond-serverless-scaling-with-aws-lambda</slug>
                <track></track>
                
                <persons>
                    <person id='30200'>Many Kasiriha</person>
                </persons>
                <language>en</language>
                <description>&quot;We know that quick feedback of automated tests is often essential.  
Once we start a test run, we don&apos;t want to wait for hours.

While browsing through the AWS products, I found a product called Lambda.
&#8220;[...] a serverless, event-driven compute service that lets you run code for virtually any type of application [...] without provisioning or managing servers.&#8221;  
Running code without servers?  
What would happen if that &#8220;code&#8221; was actually Robot Framework?  
And what would happen if I split my planned test into very small pieces during execution and run those tiny pieces at same time? Maybe all test suites at once? Or maybe..all tests at once?  
Let&apos;s talk about how to set up AWS Lambda for Robot Framework, look into it&apos;s possibilities and limitations.&quot;</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.robocon.io/robocon-2023-online/talk/ASXKLW/</url>
                <feedback_url>https://cfp.robocon.io/robocon-2023-online/talk/ASXKLW/feedback/</feedback_url>
            </event>
            <event guid='48df481c-73e6-5cb6-a805-3e65ad218f33' id='28558' code='ZNCBGC'>
                <room>Gather Town</room>
                <title>Expert Panel (Live)</title>
                <subtitle></subtitle>
                <type>Keynote</type>
                <date>2023-03-02T17:00:00+00:00</date>
                <start>17:00</start>
                <duration>01:00</duration>
                <abstract>Joe will interview Pekka, Tatu and Ed about Robot Framework, its capabilities and its community.</abstract>
                <slug>robocon-2023-online-28558-expert-panel-live</slug>
                <track></track>
                
                <persons>
                    <person id='31068'>Ed Manlove</person><person id='30200'>Many Kasiriha</person><person id='31067'>Pekka Kl&#228;rck</person><person id='33039'>Joe Colantonio</person>
                </persons>
                <language>en</language>
                <description>Pekka, Tatu and Ed are absolute experts in Robot Framework.
All from a different angle.

Pekka ,as the inventor and Core-Developer, has 100% insights and knowledge of its internals.
Tatu, as a long time library maintainer of Selenium Library and now Browser library and a heavily active person in the community, has knowledge about its use and its capabilities from a developer and users point of view.
Ed is one of the community leaders and keeps the community active and he is also the inventor of Robot Frameworks community organisation MarketSquare on GitHub.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.robocon.io/robocon-2023-online/talk/ZNCBGC/</url>
                <feedback_url>https://cfp.robocon.io/robocon-2023-online/talk/ZNCBGC/feedback/</feedback_url>
            </event>
            
        </room>
        
    </day>
    <day index='4' date='2023-03-03' start='2023-03-03T04:00:00+00:00' end='2023-03-04T03:59:00+00:00'>
        <room name='Gather Town' guid='4cdb8ebc-28e9-549b-8ca5-9681275e3b03'>
            <event guid='512c192f-5869-5268-b1d1-f8c33386ad84' id='27844' code='PDKBJK'>
                <room>Gather Town</room>
                <title>Community Open Space</title>
                <subtitle></subtitle>
                <type>OpenSpace</type>
                <date>2023-03-03T10:00:00+00:00</date>
                <start>10:00</start>
                <duration>07:00</duration>
                <abstract>Come and Join Us as we come together as a community to code, discuss, learn and advance the Robot Framework ecosystem forward!

Open Space is a day where people come together to share problems they have and provide solutions.  Where various projects are worked on by the participants. Where we all learn for each other.</abstract>
                <slug>robocon-2023-online-27844-community-open-space</slug>
                <track></track>
                
                <persons>
                    <person id='31068'>Ed Manlove</person>
                </persons>
                <language>en</language>
                <description>It is run like an &quot;Unconference&quot; using principals of &lt;a href=&quot;https://en.wikipedia.org/wiki/Open_Space_Technology&quot;&gt;Open Space Technology&lt;/a&gt;, not really a technology per se but a process for running ad hoc gatherings. That is there is no preset agenda but the topics to discuss and projects to work on are set at the start of the day. You as a participant help set the agenda alongside your fellow participants.

An example of our Open Space experience happened this past January at RoboCon Helsinki. After gathering together, the floor was opened to anyone who had either a project they were planning on working on or something to discuss; recording these to the list. Everyone shared which of these projects or discussions they were interested in so we could see how we needed to self organize. Once organized we broke out into groups to work for through the morning. After a break for lunch we gathered together to reconnect and reorganize for the remainder of the day.

As the name implies this event is open to anyone who wants to come and join us. More information will be provided in the week before the conference.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.robocon.io/robocon-2023-online/talk/PDKBJK/</url>
                <feedback_url>https://cfp.robocon.io/robocon-2023-online/talk/PDKBJK/feedback/</feedback_url>
            </event>
            
        </room>
        
    </day>
    
</schedule>
