WEBVTT

00:00.000 --> 00:18.680
So, hello again, now we'll have the Gium Bine, there's going to talk to us about Copa Rres,

00:18.680 --> 00:26.660
Opposen Trost, something for robotics, thank you so much, welcome everyone, welcome on

00:26.700 --> 00:35.660
this stream too. So, yeah, I'm Gium, I'm the author of like a Copa Rres, like a Rust engine for

00:35.660 --> 00:41.780
robotics. So, probably most of you read that, oh yeah, I know they'll do that just like

00:41.780 --> 00:48.660
takes to something, we'll watch it in the rest, come on, they're another spin of it, no, let me give me a chance.

00:48.660 --> 01:03.660
So, yeah, that doesn't work. Right, so the stuff to wear engine for robots, I have a good

01:03.660 --> 01:11.660
like way of kind of having a grown Copa Rres in what happened in another industry, which is the

01:11.660 --> 01:20.660
gaming industry, anyway, it's me. So, for those all enough to remember, okay, who knows what's

01:20.660 --> 01:27.660
the game on the left-hand side? Wow, nice, oh my god, like the geek, the geek dumb is here.

01:27.660 --> 01:32.660
Friends of Persia, that's the dude, I don't remember, he's never actually took his son,

01:32.660 --> 01:38.660
he's like a roto-friend thing to actually make the animations of a feast game, everything

01:38.660 --> 01:44.660
that was anchored with assembly language. And it was amazing, like back then you looked at that,

01:44.660 --> 01:50.660
I don't know, I'm gonna get up at Apple 2, it was absolutely incredible. It completely

01:50.660 --> 01:56.660
changed the way you see animations in the game, that something was like striking, it's like everything

01:56.660 --> 02:04.660
was really anchored for that game. Nothing was ever used from that implementation, but something

02:04.660 --> 02:09.060
something happening in the 90s, probably everybody knows this one in the middle, but

02:09.060 --> 02:13.780
and this one has been bought for on every single platform's ever. Let's do my

02:13.780 --> 02:19.940
doom, basically created what we call the now a game engine. And there will

02:19.940 --> 02:24.980
have something back then when they make that engine, is that a little bit lacking

02:24.980 --> 02:32.740
on a robot, you, you don't, I mean people working on a codebase and assets of

02:32.740 --> 02:37.700
a game, they are not coming from the same place. Some of them are, yeah,

02:37.700 --> 02:42.340
hardcore developers that are making algorithms, but you have like a

02:42.340 --> 02:47.140
people specialized in sounds, people specialized in 3D graphics and so on.

02:47.140 --> 02:51.380
Like in robotics, you have people that are coming from a mechanical engineering

02:51.380 --> 02:56.980
or like controls or like physics and, and the EE and so you have a lot of people

02:56.980 --> 03:04.420
that are actually working around a robot. And the industry can kind of match

03:04.420 --> 03:08.180
your from that point on. And you have like all the games today, you have triple

03:08.180 --> 03:14.260
games, you see like full studios of people that, yeah, just have like a specific view

03:14.260 --> 03:17.380
of their own games or their own like development or

03:17.380 --> 03:20.660
contributions to the game depending on where they are coming from. And you see

03:20.740 --> 03:26.820
all those games where you have today. So, compared to that page,

03:26.820 --> 03:35.940
out of the of that story and really try to really from scratch like two years ago,

03:35.940 --> 03:42.660
when I spent like 10 years really trying to to support like like robotics engineers

03:42.660 --> 03:49.940
or what he says, trying to to think what would be the best tool today. So those people

03:50.020 --> 03:54.500
can all work together on a robot efficiently and not shooting themselves in the

03:54.500 --> 04:01.940
university in the process. So what's wrong with was, that's going to be my first question

04:01.940 --> 04:12.020
for that, that you would ask. So things like Ross is amazing in it. I mean, I've seen

04:12.020 --> 04:17.380
so many students going to, I don't know, you've a university of austine or other universities

04:17.380 --> 04:23.780
here and so on. Look, look at what they can do with like so little, just few Python scripts

04:24.420 --> 04:29.060
scrap together, they have like those, they have their components, they can actually

04:29.060 --> 04:35.380
log on their on their system. But it has like, it has like, it has like,

04:35.380 --> 04:41.300
say I use flows for me when you try to get that from like a prototype to a natural product.

04:41.300 --> 04:47.060
It's actually fighting you a lot. One of the key reasons is, it is completely asynchronous.

04:47.060 --> 04:53.220
So people are going to that way because they think like, yeah, you have like a big,

04:53.940 --> 04:58.020
I don't know, multi-sweeted machine with GPUs and so on. So yeah, as a college city is good,

04:58.020 --> 05:02.660
like you have an event and then you can search to that event. So you try to optimize that,

05:03.460 --> 05:11.540
that aspect of the robot. The huge issue with as a college city, like it is done on Ross,

05:12.500 --> 05:18.980
it is non-deterministic. So what I say by non-deterministic is that you grab your

05:18.980 --> 05:25.700
your boss bags, you look them in your robot, but you never have any guarantees that when you get

05:25.700 --> 05:31.540
back your your boss bags and you try to replay your code, that your code is going to replay

05:31.540 --> 05:37.220
the same thing as what happened on the robot. And that has like a lot of like a kind of like

05:37.300 --> 05:41.620
cascading consequences when you are trying to, yeah, and make, for example, like autonomous robots,

05:41.620 --> 05:47.620
like things that are needs to be safe and where also you have like a lot of people working on

05:47.620 --> 05:52.580
that needs to reproduce a lot of cases out of the out of your robot, that they either encounter

05:52.580 --> 06:01.300
on the wild or in simulation. There is also the C++ situation. I mean, I spent literally nights

06:01.380 --> 06:10.020
on the passenger side of a cellar rinkar, wondering what the hell is going on with this code

06:10.020 --> 06:16.820
base, everything passed, like all the all the leaders passed, and I remember one that was very

06:16.820 --> 06:25.060
serious, where are like some kind of like to search the perception system, who was actually less

06:25.860 --> 06:32.180
this performance that was supposed to be, and it was a corruption, that was the limit of our

06:32.180 --> 06:39.380
user code and the and the transroarty layer, and that was a stupid for loop that somebody did

06:39.380 --> 06:45.140
where there was like an undefined behavior, and you look, seriously, like a lot of people are

06:45.140 --> 06:51.780
there are eyes on this thing, and it went through all the ways through the car. So C++, again,

06:51.860 --> 06:57.940
think about like what I said about the game engines, people are like roboticists, usually they are

06:57.940 --> 07:04.900
they see really C++ as a tool, like a school driver, they don't care, they don't care yet,

07:04.900 --> 07:08.740
they don't care about like complexity of the language and so on, they want something that is safe

07:08.740 --> 07:15.540
to run and to implement what they have in mind, which is usually math, usually both are like

07:15.540 --> 07:23.700
pure transforms, for your robots, for any algorithms including a machine learning, and yeah,

07:25.140 --> 07:33.620
C++ doesn't, and the thing also is that people often switch back to Python then, because Python

07:33.620 --> 07:39.220
is actually safe, it's hard to actually crash Python and easy to use, and then you have like

07:39.220 --> 07:44.500
questions where yeah, you have a management on your back, saying you need a robot,

07:44.580 --> 07:48.500
that needs to go to production, like as the code is in Python, and you're like now, it doesn't

07:48.500 --> 07:56.100
even keep real time, it calls in the lab, not trained on the public rules, performance is horrible,

07:56.100 --> 08:03.940
it's just terrible, you'll see with copper, I think the compulsion is more about like

08:03.940 --> 08:11.780
was being slow than actually copper being fast, also the fact is it's really dependent on your

08:11.860 --> 08:19.860
system, people try to port, was to value systems, I have it on my arch Linux, it's terrible,

08:19.860 --> 08:24.820
because like you have like so many system dependencies and package dependencies, out of the systems,

08:24.820 --> 08:30.180
something also that that really hinders people to actually have a system that is really

08:30.180 --> 08:37.700
heavily in production where you can update it and put it in the wild, yeah, and like you'll see

08:37.700 --> 08:44.340
also on the safety, so okay I took a lot of games, so about what let's let's look at

08:44.340 --> 08:49.940
at copper, so copper is when I really started it from scratch, the non-negotiable

08:50.900 --> 08:58.020
first principle I wanted to implement in there was determinism, so to be sure that what you run,

08:58.020 --> 09:04.100
so literally you run let's say something simulation even with copper, you can try it actually on

09:04.100 --> 09:12.020
the repo, you run your robot on simulation, it plugs the robot, you strip out the outputs,

09:12.980 --> 09:21.140
you rerun the product, you replay basically with a whisperer that that log, you compare the

09:21.140 --> 09:27.860
binaries of the two logs, they are exactly the same, so think about it for a roboticist, it means

09:27.860 --> 09:32.740
that those logs you can put them in the in the cloud and you can be sure that when your test

09:32.740 --> 09:37.060
gets passes, it will always pass, and when it doesn't pass, you know that you you you

09:37.060 --> 09:48.100
regress somewhere, so it's also designed for safety, conceptually, so conceptually actually copper

09:48.100 --> 09:55.140
is a lot of things, one it's a compiler, I just basically copper extends with macros in rest,

09:55.460 --> 10:04.740
the rest compiler to actually create your run time, we don't depend on anything, so much that

10:05.300 --> 10:10.500
you could say that copper is an actual operating system, you say Ross is an operating system,

10:10.500 --> 10:16.740
it's not, that is an operating system, I have a file system, I have a scalar and I run like

10:16.740 --> 10:23.380
bare metal, you can run on STM32 if you want, but it runs off course on standard process,

10:23.380 --> 10:28.420
we'll time a minute, but you can also run it like bare metal, because yeah, I depend on nothing,

10:30.660 --> 10:36.420
it's very performant, like like high bond wave, low latency, we are like out of the box,

10:36.420 --> 10:44.660
if you want to do, I have some examples in the repo, if you want to do the same chain of tasks

10:44.740 --> 10:53.860
that you run and log for each of them, for the latency, I have 100x faster than Ross, so that's

10:53.860 --> 11:00.260
100x, yeah, because like it generates basically the operating system to run your robot, you design

11:00.260 --> 11:05.860
your robot, you say to copper what you want to run and it accommodates you, the system around

11:05.860 --> 11:11.380
your your the architecture of your robot, so it's very out to be, I mean it tries to chain up like

11:11.460 --> 11:17.700
all the tasks back to back in memory, with like that architecture, so it's always like hitting

11:17.700 --> 11:22.740
all the cashees and the linearity of all your systems, same thing for logging, actually,

11:22.740 --> 11:28.820
logging with log, we don't log, like Ross bugs are kind of like indexed and all over the

11:28.820 --> 11:36.260
place on an hard wife, we log so linearly that we don't need a file system, so you give it a partition

11:36.820 --> 11:42.500
linearity, we log back to back to back to back to back, so for an NVMe for example,

11:42.500 --> 11:47.620
it's the difference between seven gigabytes per second to something that is five on the right

11:47.620 --> 11:52.100
of the megabytes or six on the megabytes per second, that's the difference of successful

11:52.100 --> 11:57.460
product or not, because yeah, if you want to match that performance, you need 10 times more like

11:57.460 --> 12:03.060
NVMe's, how do I know? Actually, actually I can still set the ring cards, we're hard to put like

12:03.220 --> 12:09.540
a raise of NVMe's, where I was like what the hell are we doing? And the digital also is

12:09.540 --> 12:14.900
important, something that you realize quickly with robots in a conformant environment, you're

12:14.900 --> 12:22.740
robots will run nicely, but also the need you have more people or more objects around your

12:22.740 --> 12:28.980
your thing and if your own system adds some noise into the measurement, you don't know

12:29.060 --> 12:34.180
in terms of performance like, okay, what three girls that kind of like randomness into your

12:34.180 --> 12:43.300
the execution of your own right? So yeah, all in all, that's all those people to focus on algorithms

12:43.300 --> 12:50.580
and not all the details I told you, compared to that for you, on at compile time. Should we try

12:50.660 --> 13:02.260
a demo? Can you make a prayer to the demo girls? So that's on the repo, you can actually try it

13:02.260 --> 13:10.820
yourself and one thing I tried really hard to do is that you know what, that's just a rest up,

13:10.820 --> 13:16.660
you don't have cool cool things off, special makes fires or whatever, that's it, that's my

13:16.740 --> 13:29.620
non-negotiable, you can go on and it should run each, maybe.

13:37.700 --> 13:45.540
Come on, no, yes, yes, yes, yes, yes, yes, yes, maybe I'll make it.

13:47.540 --> 13:54.260
Here we go, so that's a very simple robot, which is like a safe balancing rod. I do that because

13:54.260 --> 13:59.860
I don't want to explain to you a robot, so everybody knows this example actually, you don't see

13:59.860 --> 14:10.340
my cursor but you try to try to show you, so that's just a self balancing rod like in a

14:10.340 --> 14:17.780
run in a simulator, I do have the actual robot at home. It runs exactly the same code,

14:17.780 --> 14:26.580
if I can't really see what I'm doing, but so you see, so that's basically bevy, bevy is like

14:26.580 --> 14:34.740
a game engine in in copper, but we do, we do support like values like simulator, it's just one

14:34.740 --> 14:40.580
that is easy because because of this copper run, like that's like a rust deponentive, so I can run it

14:40.580 --> 14:45.540
straight away, you can see a little bit like the console, there is a console like to monitor real

14:45.540 --> 14:54.660
time what is happening on the robot, so it shows you, here the structure of the robot itself,

14:54.660 --> 15:00.980
so that's a big config file that is modular, you can add that, so the big difference between

15:00.980 --> 15:08.020
was and copper is that you actually define your robot a lot of time, so you say what's going to be

15:08.020 --> 15:12.660
connected to what and who is sending a message to what, that's part of the determinism aspect of it,

15:13.300 --> 15:18.100
but still, still at the same concept, you have a task, you have input outwards and you

15:18.100 --> 15:23.060
talk like you can have send messages even if you don't really send messages in that example

15:23.860 --> 15:31.060
and you can visualize that they are like this little kind of dag, where you have on the left-hand side

15:31.860 --> 15:40.420
sensors, those are, this was a Raspberry Pi running, like some algorithms, the PID is really simple

15:40.420 --> 15:49.940
and the actual output on the right-hand side, so this thing also, when you look at the other latency,

15:50.580 --> 15:54.580
so you have some zeros, because some of them are actually simulated, the other ones are actually

15:54.580 --> 16:00.420
executed, so I give you the number on the simulator there, but you will have the same thing on the robot,

16:00.420 --> 16:07.540
you see, I mean that's a small laptop, it's measured in microsegons and if I run that on my

16:07.540 --> 16:13.780
desktop, it's going to be in nanoseconds, basically, sometimes it's zero because with the super

16:13.780 --> 16:21.140
scale of the CPU, you can have actually data that is going so fast and we measure twice,

16:21.140 --> 16:31.780
the same timestamp on the CPU clock, and I'm talking like that, but you would say like,

16:31.780 --> 16:36.740
why do you need nanoseconds of latency, but think about it, like when you have a good

16:36.740 --> 16:42.100
logger, like we have, and a low latency, suddenly you can think about your robot and actually

16:42.100 --> 16:47.460
subdivides your robot with like blocks that are that are as small as possible, so these

16:47.460 --> 16:53.540
you visibility on every single blocks input out, input out, input out, input out, and basically for free,

16:53.540 --> 17:00.900
so you can, I don't know, you can put like 10 12 layers of of of blocks like that and you have like,

17:01.860 --> 17:07.220
I don't know, one microsegons of latency and two, and if this is pure CPU, that's pretty cool,

17:07.860 --> 17:13.940
I mean, over at the top of what you're doing, of course, if you're spending three seconds on

17:13.940 --> 17:23.460
your past, it will show. In terms of bandwidth, so that's kept to the simulator, like 60

17:23.460 --> 17:29.860
frames per second, something, like that's where you can see what's the efficiency of the

17:29.860 --> 17:34.820
logging, what's the bandwidth you use, because often like what happens when you are building a robot,

17:34.820 --> 17:40.740
you hit, you hit like limits on your system that are actually not CPUs, there are either Io,

17:40.740 --> 17:47.140
or or memory bandwidth, often, because you're drawing like images or light up points, like super

17:47.140 --> 17:52.260
AV things, that's why I really want you to have that view where robotics is can show like, oh,

17:52.260 --> 17:57.300
wait, I just I did like a camera, a camera, or like a new light up, what's going to be the

17:57.460 --> 18:06.340
cost in terms of performance, and yeah, that's pretty it. I can show you something I have seven

18:06.340 --> 18:14.820
minutes, so I try to, can show you how it looks like, so you define your tasks on, that's the one

18:14.820 --> 18:22.980
you've shown a little graph, and it's just like you tell it basically an ID, so you can collect them

18:22.980 --> 18:30.900
and refer to them in the logs, you give them a type that is kind of, it's just like a rust type,

18:30.900 --> 18:35.620
that implements like few traits depending on what type of component you are building,

18:36.660 --> 18:43.300
and yeah, you can give it like those ones are like other configurations, those are tuning for

18:43.300 --> 18:51.060
PIDs, so it's pretty self-explanatory, and you, you connect them, so basically you say, oh, I want

18:51.140 --> 18:55.220
to connect this source with this destination, with this message, very, very simple.

19:02.580 --> 19:09.620
Yeah, let's go back to the plantation. So yeah, I want to be sure that you have some

19:09.620 --> 19:14.660
times for questions, which is usually, I trigger a lot of questions that would have that presentation,

19:15.220 --> 19:19.940
so I would like to explain the amazing community, I've like a bunch of contributors,

19:19.940 --> 19:28.100
now on copper, and yeah, we are moving forward a lot, we just, we aren't exactly like this,

19:28.100 --> 19:37.460
bunch of like either middleware, like they know, or I saw eggs, we do, I think we've actually

19:37.460 --> 19:46.820
exceeded the algorithm, like cornea, we are like hanging face and fire and algebra, the algebraic,

19:47.540 --> 19:56.500
systems on unrest, so it's really copper is one thing that is actually growing together, a

19:56.500 --> 20:04.100
little bit, all that risk of, of like in robotics, that is actually growing, and re-inventing a

20:04.100 --> 20:09.060
little bit like what I did with copper, a lot of things are actually not just re-wrote in

20:09.060 --> 20:13.540
unrest, but actually re-inventing unrest, and that's quite amazing, and I'm super happy to be part of

20:14.420 --> 20:20.020
that ecosystem. Of course, like the two ones, at the bottom we talked about like re-run and first

20:20.020 --> 20:27.540
glove, so for example, it's more like a, you saw that before, like a visualizer, re-run as also,

20:28.420 --> 20:33.700
as also like an amazing integration with copper, because it integrates, of course, at the

20:33.700 --> 20:40.340
rest of the value API level, so it's in two lines, of course, you can actually show what's going on

20:40.420 --> 20:47.780
in re-run for, or what's going on in copper, always re-run. One small ask, if you like

20:47.780 --> 20:54.420
what I'm doing, you are supporting a project, yeah, please, stay on a little report would be amazing.

21:04.260 --> 21:08.900
The first thing to thank you very much, that's a lot of work and I appreciate that.

21:10.420 --> 21:13.620
How does this framework interact with the programming languages, in particular Python, which is

21:13.620 --> 21:17.460
taking our robotics with all the machine learning approaches, which in there, this calling

21:17.460 --> 21:23.700
it's supposed to last, I know, but how does it interact? Yeah, no good question, so we do have already

21:23.700 --> 21:30.340
Python API, but for the logs, because for example, you don't want to do that analytics in

21:30.340 --> 21:38.420
the rest of the year, so our rest, our logging is actually an API, and so we can use that to

21:38.420 --> 21:43.940
explore that to other systems, like we said, for folks love, but also you can get that and get

21:43.940 --> 21:52.260
straight, you get your robot, you can have your Python worksheet, and you can actually get the

21:52.260 --> 22:01.700
data straight out of Python interface. Life data, too? Life data, too? Life, the topic is looking at

22:01.700 --> 22:08.340
that data, you could do it, we don't support it yet, but we could, so we do have what we call

22:08.340 --> 22:15.620
like bridges, also, where you can integrate with your Python code, we use zero, for example, for

22:15.620 --> 22:24.900
that, where you can actually, like to meet the data, to a channel, and you have bindings for those

22:24.900 --> 22:31.620
like types in Python, so you can do that, like remotely. What we haven't done yet is actually

22:31.780 --> 22:39.780
enabling Python itself in the tasks of the robot, it's not hard to do, like you know, like

22:39.780 --> 22:46.180
tooling in rest, that is doing that very nicely, but I'm a little bit scared, because like then you

22:46.180 --> 22:52.660
have like the, a little bit the duration, a lot of like people contribute just Python, while

22:52.660 --> 22:57.300
I really, especially where I am in the community today, I really want like solid like building blocks

22:57.460 --> 23:02.900
for basic things, like drivers or like, I don't know, ICP, and those kind of like simple things

23:02.900 --> 23:08.500
that I really want to be nailed. At some point I will implement like a first class Python,

23:08.500 --> 23:13.540
super, for sure. So you have bridges, like let's say we have our system, we want to migrate towards

23:13.540 --> 23:17.540
your system, so we start with whatever we have, I'm going to say Ross, because that's what we have.

23:17.540 --> 23:22.660
And we want to migrate some elements to your OS, do you have bridges set up, so you can

23:22.740 --> 23:27.860
correct. Yes, so we do have a translation layer for Ross too, so you can also talk to Ross

23:27.860 --> 23:30.580
too soon, but that also one of your escape arch from Ross.

23:34.580 --> 23:40.580
Thanks so much for the talk, I'm really calling concepts and I think that Ross could learn a lot from

23:40.580 --> 23:48.740
from that, but I, this thing on your website that you say that you have a patent on copper,

23:48.740 --> 23:55.220
could you verify that? Actually, yeah, actually I let it expire. So I had a provisionary patent on

23:55.220 --> 24:00.260
on it and it's not that much, but what's going to happen now? What's going to happen with

24:00.260 --> 24:07.060
Arcas, I'm not even going to touch suffer that. Yeah, no, it's not patent today, actually.

24:07.060 --> 24:11.540
Okay, it's it was a pre-minuary patent, so basically it's not a patent just like saying maybe

24:11.540 --> 24:16.740
we, I would, I would patent it and I decided to not, to not, it would be good if you updated the

24:16.820 --> 24:22.580
website because for me, it was like, it's very, yeah, yeah, I'm going to touch this. Okay, cool, thank you.

24:25.860 --> 24:27.380
Goodmath, thank you for one more.

24:29.460 --> 24:36.740
Hey, my question is, if you, if you have a system that's built on Ross too already,

24:36.740 --> 24:42.500
what is the migration path if I, I really like what you're doing? Yeah, I, I don't understand

24:42.500 --> 24:47.140
like, do we have to start from scratch and we'll build everything? There are like, there will be

24:47.140 --> 24:54.500
questions. So, so we have a system and one of our users is doing that actually and what are

24:54.500 --> 25:00.180
recommend usually is to, so we have a bridge between copper and Ross too and so you can send

25:00.180 --> 25:04.980
messages from one to another. So your, your copper system can act as like a big,