WEBVTT

00:00.000 --> 00:13.000
Thank you so much for this warm welcome.

00:13.000 --> 00:19.320
So I'm Julia Nock, so I have to protect our data scale and commit there on Eclipse

00:19.320 --> 00:27.120
Zeno and yes, I am here with my colleague, you are on our rune.

00:27.120 --> 00:32.480
So you are also at data scale is the main developer of RZ, the project we will demonstrate today

00:32.480 --> 00:38.800
and you are also of course maintainer on MWZ no for RZ.

00:38.800 --> 00:43.920
So what's journey we had to go to RZ, right?

00:43.920 --> 00:50.840
We started working on Zeno of course, I guess a lot of you have already a but the no right

00:50.840 --> 00:58.480
or what we use it using it and we developed MWZ no for RZ 2 with the help of Intranciac,

00:58.480 --> 01:02.720
we collaborate with Intranciac for this with UME.

01:02.720 --> 01:09.920
And first let's have a dive into the lasagna plates as HSTV call it, the big lasagna of

01:09.920 --> 01:17.920
RZ 2 with all the layers that we have, your application on top, based on several different API

01:17.920 --> 01:23.920
in different language, C++, Python, Java, the RCL API which is a command layer for

01:23.920 --> 01:29.800
high level concept in the in-house like actions, parameters, names and the R&W which is an

01:29.800 --> 01:37.000
abstraction of MW and we have the MW implementation, traditionally based on DDS, starting with

01:37.000 --> 01:43.000
fast DDS, being the default currently, cyclone DDS as another option and in the last

01:43.000 --> 01:50.560
year we worked on Zeno, MW based on Eclipse Zeno and Eclipse Zeno is the lock in RZ, right?

01:50.560 --> 01:58.280
So we have RZ at the very bottom on this architecture and because all the RZ stack starting

01:58.280 --> 02:06.160
with R&W are developed in C and C++, we leverage in R&W Zeno, Zeno, C and Zeno, Cpp and

02:06.160 --> 02:12.280
the core of R&W Zeno is the lock in C++.

02:12.280 --> 02:14.800
How is it developed using Zeno?

02:14.800 --> 02:19.880
It's quite simple, Zeno provides pubs sub, provides queries based on what we name key expression,

02:19.880 --> 02:26.480
key expression is just a string with slashes as separator, so Ross need a convention to use

02:26.480 --> 02:31.720
Zeno in the way to express all the ross concept in Zeno.

02:31.720 --> 02:35.720
So topic service and names are mapped on key expression in this key expression you can find

02:35.720 --> 02:41.240
the domain ID which is still used, you can find the namespace, you can find the topic name

02:41.240 --> 02:45.880
that you can find also the topic description with the type name, string for instance, and

02:45.880 --> 02:48.040
I type hash.

02:48.040 --> 02:53.720
That's the way R&W Zeno is mapping all the ross concept into Zeno.

02:53.720 --> 03:00.260
For graph declaration, when you declare a node to be discovered by all the nodes and

03:00.260 --> 03:04.720
pubs share sub fiber to discover by all the nodes.

03:04.720 --> 03:09.040
We are using live nestocone, so live nestocone is a concept in Zeno where you can declare

03:09.040 --> 03:19.040
a simple R&W, this key expression is tied to the Zeno session declaring the live nestocone,

03:19.040 --> 03:24.800
and as soon as there is a disconnection or there is a loss of communication with the

03:24.800 --> 03:30.160
session, the client is a live nestocone, every other session can receive an notification,

03:30.160 --> 03:32.160
the live nestocone is gone.

03:32.160 --> 03:38.040
So we can build a full discovery and also a monitoring for totally distributed between all

03:38.040 --> 03:41.720
the nodes using live nestocone.

03:41.720 --> 03:47.160
Once you have this, you need to send data in it, so data are just saying like in the DS with

03:47.160 --> 03:52.000
CDR encoding as a payload as a buffer, and we add some attachments for the second number

03:52.000 --> 03:54.320
to attach funds and the group ID.

03:54.320 --> 04:01.360
So why I'm explaining this, it's because already any Zeno application, any user developing

04:01.360 --> 04:06.920
Zeno can do exactly the same to be interoperable with R&W Zeno and with us too, right?

04:06.920 --> 04:14.600
That's actually what did a company named UBQT robotic, the leverage or Deno product for

04:14.600 --> 04:20.440
embedded, which is named Zeno Pico, and on top of this there will pick us, because it's just

04:20.440 --> 04:26.920
a thin wrapper on Zeno Pico, using the same pattern, and then you can have Mico controller

04:27.000 --> 04:32.840
communicating with your Rost2 stack using R&W Zeno.

04:32.840 --> 04:39.280
And then we wonder, okay, we have this big Lzanya plate with Rost on the bottom, and we

04:39.280 --> 04:42.880
would like to have, of course, Rost API.

04:42.880 --> 04:48.440
So what about a pure Rost stack, right?

04:48.480 --> 04:57.440
If you look at what the Rost2Rost project is doing, and no, don't get me wrong on this,

04:57.440 --> 05:01.320
I have a good respect for what they are doing, and it's really important because it's

05:01.320 --> 05:07.560
open all the Rost ecosystem for a complete Rost stack, but the constraint is that they need

05:07.560 --> 05:14.040
to cope with the existing Rost2 ecosystem, and to add up to also the existing middleware,

05:14.040 --> 05:15.040
right?

05:15.040 --> 05:20.960
Anyway, they need to have this FFI, this Interface between the RostCode, and the C-Code,

05:20.960 --> 05:28.120
because all the core of RCL and R&W, some middleware, like FSDDS or Cyclone, are developing

05:28.120 --> 05:29.600
C, right?

05:29.600 --> 05:33.960
But when you go to use R&W Zeno, you will come back to Rost.

05:33.960 --> 05:41.760
So you will cross the FFI at a second time from C to Rost, and we were wondering, is it

05:41.760 --> 05:42.760
a PTE?

05:42.760 --> 05:50.320
What can we gain if we have a complete Rost stack from the user application down to Zeno?

05:50.320 --> 05:59.120
And that what we are trying to achieve with RostZ, a complete Rost stack, implementing, for

05:59.120 --> 06:07.440
no, it's a very basic Rost2 concept, such as actions, purposes, services, discovery, but

06:07.480 --> 06:09.120
also type the adaptation, right?

06:09.120 --> 06:18.120
Because you want to use Rost type with your application, and to have Executory Stalkio,

06:18.120 --> 06:26.160
which is a famous Async and quite used with Rost, still maintaining the Interoperability

06:26.160 --> 06:28.360
with R&W Zeno.

06:28.360 --> 06:30.360
So what does it open?

06:30.360 --> 06:36.080
As I still mention, it opens the safety of the core, because you are fully in Rost, noise,

06:36.080 --> 06:38.160
signal, and safeguard in here.

06:38.160 --> 06:43.840
It opens also the possibility in the future to certify, or the stack, right, and to certify

06:43.840 --> 06:48.440
from end to end, from the middle way up to the user application.

06:48.440 --> 06:54.840
And it will open a lot of the Rost case, as we will discuss in the next slide.

06:54.840 --> 07:02.040
So the main goal was to have a 100% Rost stack using Builder Patents for Avalu TVT, so the

07:02.040 --> 07:08.360
Builder Patents are traditionally used in Rost in order to expand an API without breaking

07:08.360 --> 07:10.920
the backward compatibility.

07:10.920 --> 07:15.120
Cargo build, so because the stack is full of Rost, right?

07:15.120 --> 07:19.560
We don't need to have dependency on other packages like C package, so we don't need

07:19.560 --> 07:26.880
any more core currency resultant, so we can use just Cargo.

07:26.920 --> 07:32.040
Rost that if Rost to application, so prep serve service action, and Rost discovery,

07:32.040 --> 07:35.240
that's a minimum minimum we would like.

07:35.240 --> 07:40.160
But we included, meaning zero Rost to dependency requires, meaning implying that you can deploy

07:40.160 --> 07:44.240
Rosts on any target supported by Rost.

07:44.240 --> 07:51.040
So any Rost platform, and of course, interoperability with RMW Zeno, but also we wanted

07:51.040 --> 07:57.440
to open the possibility to have alternative encoding, because a lot of people want to

07:57.440 --> 08:02.440
explore, probably using, for instance, protobuff, c-bore, or maybe JSON in some time, if

08:02.440 --> 08:10.440
you want to communicate with a UI, JSON might be also some time, a good solution.

08:10.440 --> 08:13.800
So let's dive into the details with UUAN.

08:14.120 --> 08:15.120
Okay.

08:15.120 --> 08:16.120
Let me go.

08:16.120 --> 08:17.120
I already have one.

08:17.120 --> 08:18.120
Okay.

08:18.120 --> 08:21.120
I was all nervous.

08:21.120 --> 08:22.120
Okay.

08:22.120 --> 08:24.960
Hi, everyone.

08:24.960 --> 08:29.960
So although I will dive in, but I will make it very easy to understand.

08:29.960 --> 08:35.440
So let's read the three main pillars of Rostset, the left-hand side is the current one,

08:35.440 --> 08:44.720
I'm the original CPP, let we cooperate with Intrinsics, I'm the original C++ binding,

08:44.720 --> 08:50.120
I'm top of the Xeno C++ binding, I'm top of the Xeno Rost, Xeno is ready in Rost.

08:50.120 --> 08:58.400
And the right one is our new POC, let we use the Rostset, which I'm the features enabled,

08:58.400 --> 09:04.160
and then we can, I'm top of it, have a Rost version of W, okay.

09:04.160 --> 09:08.560
And then we also support RCO and the UUU Rost 2X.

09:08.560 --> 09:15.360
And in the middle one, it's a less text, let's use the Rost and use Rostset as a framework,

09:15.360 --> 09:21.200
then we can build any Rostset on top of it, with the R&W-Zeno C++ binding, okay.

09:21.200 --> 09:28.400
So this is a very overview that I'm getting, okay.

09:28.400 --> 09:35.040
In case this audience is not familiar with how R&W works.

09:35.040 --> 09:43.080
So R&W in Rost is some easy way to switch the underlying transportation layers.

09:43.080 --> 09:48.560
So for example, you want to talk her and listen her, they would like to communicate

09:48.560 --> 09:54.480
with each other and you want to customize the transportation, then you set an environment

09:54.560 --> 10:02.320
variable to switch R&W you want to set, like here, R&W-Zeno Rost, okay.

10:02.320 --> 10:10.240
But in Rostset, we have more, like, is somehow like RCO layer.

10:10.240 --> 10:16.160
So you can spawn a node like this one, this is Rost English, and you can use a builder

10:16.240 --> 10:21.920
pattern, like with some specific QOS, lift the others, use a default values,

10:21.920 --> 10:24.560
and you can customize your service.

10:24.560 --> 10:28.000
If you want to use a CDR, you don't need to use it because it's by default.

10:28.000 --> 10:30.720
But if you want to use PoloBuff, we also support it.

10:30.720 --> 10:37.840
So the Rost message build with Rostset, you can build with PoloBuff support, directly.

10:37.840 --> 10:41.200
It's just a feature-flake, okay.

10:42.160 --> 10:53.040
And for a more, if someone already used CDRs and they used to use Deno Pronging DDS, Rost2DDS,

10:53.040 --> 11:00.320
or Deno Brig Rost2DDS, they used two different schema, or I call it key expression backend.

11:00.320 --> 11:04.400
In Rostset, we also support easy switch to support it.

11:04.400 --> 11:10.640
So if you still want to use CDRs and also leverage the power of Deno, in Rostset,

11:10.640 --> 11:13.600
you can direct switch it by with backend.

11:13.600 --> 11:16.640
So we have a very strong compatibility, okay.

11:20.880 --> 11:26.480
And in Rost, we have very ergonomic ACing API.

11:26.480 --> 11:33.040
So in Rostset, you can call D-pop publish, or D-pop ACing publish.au,

11:33.040 --> 11:35.280
but you need an ACing runtime.

11:35.280 --> 11:41.280
Then you can leverage the ACing I-O to not block the ACing schedule.

11:41.280 --> 11:44.880
And also we support two patterns of subscriber co-peck.

11:44.880 --> 11:48.480
One is a co-peck, and another one is a pouring style.

11:48.480 --> 11:53.040
So this one is common one using the Rostset or CBP.

11:53.040 --> 11:56.720
You build with a co-peck and feed in a function.

11:56.720 --> 12:02.720
Another way is PoloSile, let you can hear that, okay, and until you receive some message.

12:02.720 --> 12:06.560
And this receive could be an ACing code as a function code.

12:06.560 --> 12:10.720
So you can say sub.acingReceive.au.

12:10.720 --> 12:16.160
So you can have a streaming style, very easy to write a code.

12:19.760 --> 12:26.560
Okay, and we also support action service, like server and client here,

12:26.560 --> 12:28.560
also very easy to use.

12:29.280 --> 12:36.720
But there's something I want to highlight this one, co-co-tock.

12:36.720 --> 12:40.160
So why we want to use RostEnglish?

12:40.160 --> 12:47.760
Because you can have a very detailed documentation, or this one.

12:47.760 --> 12:50.800
In Rostset, you can build up this.

12:50.800 --> 12:56.160
For example, you can query the definition of Z-pop builders,

12:56.160 --> 12:59.680
and then you can know what's the type on it.

12:59.680 --> 13:04.240
So let you can select, I want to use CDR, or PoloPath.

13:04.240 --> 13:09.600
And you can know the fields, these Christians here,

13:09.600 --> 13:14.160
I want to attach something, or enable share memory.

13:14.160 --> 13:16.880
Okay, so for example here, I demonstrated,

13:16.880 --> 13:21.600
you can customize per publishers, share memory like this.

13:21.600 --> 13:24.560
This is not even possible in RostEnglish.cpp.

13:24.640 --> 13:29.120
You can customize each node, each publishers,

13:29.120 --> 13:35.200
a very fine-grained control, and send it with your customized share memory.

13:38.400 --> 13:41.680
So every detail can be found in the cargo duct.

13:42.000 --> 13:52.240
Okay, and for the more Python API is also supported.

13:52.240 --> 13:58.880
So you can write easy Python code with the same patterns, build up a context,

13:58.880 --> 14:02.160
and build out a node from the context, and build out the publishers,

14:02.160 --> 14:07.280
and the subscriber, also a very easy polling style.

14:07.280 --> 14:10.000
So receive and then do a processing.

14:10.800 --> 14:13.360
CodeBag is also supported.

14:13.360 --> 14:15.600
And this one might be very cool.

14:15.600 --> 14:18.240
If you follow RostEnglish course,

14:18.240 --> 14:22.080
there's a recent discussions on the SEO native's buffer,

14:22.080 --> 14:26.880
and developers may want to leverage the CUDA tensor,

14:26.880 --> 14:30.800
or use the CUDA IPC, but the buffer needs to be

14:30.800 --> 14:34.880
aware of the transportation and best transportation for CUDA,

14:34.880 --> 14:37.440
for other GPU buffers.

14:37.440 --> 14:40.560
So in RostEnglish, we try to provide another solution

14:40.560 --> 14:43.200
to possibly achieve it.

14:43.200 --> 14:47.600
So the left hand side is a point-out definitions in Rost,

14:47.600 --> 14:53.280
which contains a lot of headers, but there is a U8 array data.

14:53.280 --> 14:56.000
This one could be very huge, right?

14:56.000 --> 14:59.360
And in RostEnglish, while we do the code generations,

14:59.360 --> 15:02.720
we will wrap it in general buffer.

15:02.720 --> 15:06.160
And this general buffer respects the share memory.

15:07.120 --> 15:12.320
So you can use this, I can customize my share memory provider.

15:12.320 --> 15:16.480
This one is so far, it's just a passage share memory,

15:16.480 --> 15:23.280
but it could be extend to CUDA or GPU device

15:23.280 --> 15:25.680
aware providers.

15:25.680 --> 15:33.520
And then they will respect the area or the device to send it.

15:33.520 --> 15:38.480
If you find the data is in the same area or in the same group,

15:38.480 --> 15:41.680
you will send over the share memory.

15:41.680 --> 15:44.400
OK, so there's a little things we do.

15:44.400 --> 15:49.600
We will translate the important data like this,

15:49.600 --> 15:52.880
could be huge, and we wrap it as share memory buffer.

15:56.000 --> 16:00.560
OK, and then I also want to demonstrate a cool features

16:00.560 --> 16:03.360
that is called RostEnglish.

16:03.680 --> 16:06.720
OK.

16:14.560 --> 16:16.640
Is it Peri?

16:18.960 --> 16:22.160
This no network here.

16:22.160 --> 16:25.200
So it forced me to do a live demo.

16:27.680 --> 16:30.240
Don't worry, I have backup plan.

16:30.240 --> 16:32.800
Yeah, so just a quick call on this,

16:32.800 --> 16:39.000
rights, because we are in rust and because rust are such a rich ecosystem, maybe you heard

16:39.000 --> 16:46.720
about right at U.A., which is a very nice cool framework to build in the shell consoles.

16:46.720 --> 16:53.040
And what you and did is really using right at U.A., to incongruption with us, to have something

16:53.040 --> 16:55.040
to explore our system.

16:56.040 --> 17:02.040
Thank you so much.

17:02.040 --> 17:05.040
Thank you so much.

17:05.040 --> 17:07.040
Thank you so much.

17:07.040 --> 17:08.040
Okay.

17:08.040 --> 17:10.040
So this lifetime moment demonstrated.

17:10.040 --> 17:12.040
You'll spawn a usual general router.

17:12.040 --> 17:15.040
And then I'll spawn the talker.

17:15.040 --> 17:19.040
Let's repeat the published laser scan.

17:20.040 --> 17:28.040
And then as you can see here, I can have about three versions.

17:28.040 --> 17:29.040
Okay.

17:29.040 --> 17:40.040
And then I can select it to major, major, major, major, and then boom.

17:40.040 --> 17:41.040
Yeah.

17:41.040 --> 17:48.040
And I can press record to store it in a SQLite database and also filter to find out

17:48.040 --> 17:50.040
your interesting topics.

17:50.040 --> 17:52.040
Yeah.

17:52.040 --> 17:53.040
Okay.

17:53.040 --> 18:01.040
So it is a quick demo session.

18:01.040 --> 18:02.040
Okay.

18:02.040 --> 18:03.040
But I still have time.

18:03.040 --> 18:17.040
So I want to show you something more interesting.

18:17.040 --> 18:23.040
I'm not sure you guys know what is type description and dynamic subscriber.

18:23.040 --> 18:27.040
So in Rust, it's possible to create a dynamic subscriber, right?

18:27.040 --> 18:32.040
But a dynamic subscriber could be once in very interesting set.

18:32.040 --> 18:38.040
If you support the type descriptions, you can pass the message schema already.

18:38.040 --> 18:40.040
We only have it in Rust.

18:40.040 --> 18:42.040
There's no Rust package dependency.

18:42.040 --> 18:45.040
You can even run in MegaOS.

18:45.040 --> 18:51.040
And I try to pass it.

18:51.040 --> 18:54.040
And you will print out the message here.

18:54.040 --> 19:03.040
So as you can see here is, oops.

19:03.040 --> 19:04.040
Okay.

19:04.040 --> 19:11.040
I can even do something like this along.

19:11.040 --> 19:12.040
Oops.

19:15.040 --> 19:21.040
I can do something like I even disabled a co-com.

19:21.040 --> 19:26.040
So remove any Rust to dependency.

19:26.040 --> 19:28.040
But it still can print it.

19:28.040 --> 19:30.040
Dynamic pass it.

19:30.040 --> 19:33.040
So you can, I can provide a standard loan.

19:33.040 --> 19:34.040
Cancel.

19:34.040 --> 19:36.040
Let work on any platform.

19:36.040 --> 19:37.040
Okay.

19:37.040 --> 19:41.040
So let's go back to the slides here.

19:42.040 --> 19:49.040
And then they will attack, that doesn't work well.

19:49.040 --> 19:58.040
So, so about this, I want to quickly go through this one.

19:58.040 --> 20:02.040
So this is so far our benchmark with the others.

20:02.040 --> 20:06.040
Maybe you, you guys will be interested in this one is Rust set.

20:06.040 --> 20:09.040
Python by the, Rust API in general.

20:10.040 --> 20:13.040
And Rust set, that is our characters.

20:13.040 --> 20:16.040
And as you rust, and as you see,

20:16.040 --> 20:18.040
both of them use general.

20:18.040 --> 20:20.040
And that is for small messages.

20:20.040 --> 20:23.040
And as you can see, Rust set is the best.

20:23.040 --> 20:24.040
For.

20:30.040 --> 20:32.040
Hi for conces, small panels.

20:32.040 --> 20:34.040
Hi for conces, middle panel.

20:34.040 --> 20:37.040
Hi for conces, what make up, bite.

20:37.040 --> 20:40.040
And.

20:40.040 --> 20:45.040
The streaming test, with economic advice.

20:45.040 --> 20:46.040
Okay.

20:46.040 --> 20:48.040
So that is Rust set.

20:48.040 --> 20:49.040
This one.

20:49.040 --> 20:51.040
Okay.

20:51.040 --> 20:52.040
Okay.

20:57.040 --> 20:58.040
Yeah.

20:58.040 --> 21:00.040
So.

21:00.040 --> 21:02.040
But you can.

21:02.040 --> 21:05.040
There are something interesting here is as you can see,

21:05.040 --> 21:08.040
our Rust set Python by the, is quite efficient.

21:08.040 --> 21:12.040
It's just a little overhead compared to Rust by the,

21:12.040 --> 21:15.040
for example, here almost equivalent.

21:15.040 --> 21:19.040
But we, we, we still need to improve low serializations,

21:19.040 --> 21:24.040
because our Rust API is still worse than our Rust by the,

21:24.040 --> 21:25.040
a lot.

21:25.040 --> 21:28.040
But better than Rust API.

21:28.040 --> 21:30.040
Okay.

21:30.040 --> 21:33.040
So if you want to use a Python by the,

21:33.040 --> 21:37.040
I suggest you to use Rust API.

21:37.040 --> 21:38.040
Okay.

21:38.040 --> 21:42.040
So finally, let us have a wish list.

21:42.040 --> 21:45.040
The goal by the, we are coding working on,

21:45.040 --> 21:47.040
because we found sponsors.

21:47.040 --> 21:50.040
And the next one is,

21:50.040 --> 21:53.040
many people want us to implement

21:53.040 --> 21:55.040
Lakuda.

21:55.040 --> 21:59.040
Poverse or support the Python sensors.

21:59.040 --> 22:00.040
Okay.

22:00.040 --> 22:04.040
So we also know it's the features to make it run and embedded devices.

22:04.040 --> 22:06.040
It's also possible.

22:06.040 --> 22:10.040
And for scarves support a better lunch and systems in Rust,

22:10.040 --> 22:13.040
more efficient with Rust set.

22:13.040 --> 22:14.040
Yeah.

22:14.040 --> 22:17.040
So let us, the end of our talk.

22:17.040 --> 22:18.040
Any questions?

22:18.040 --> 22:20.040
I think we have a few more slides just,

22:20.040 --> 22:22.040
some acknowledgement slides.

22:22.040 --> 22:23.040
Sorry. Yes.

22:23.040 --> 22:24.040
Because.

22:24.040 --> 22:25.040
Yes.

22:25.040 --> 22:26.040
We have some, some sort of right.

22:26.040 --> 22:28.040
We are participating in some European projects.

22:28.040 --> 22:31.040
And so they know is partially funded with,

22:31.040 --> 22:34.040
by all those European project, right?

22:34.040 --> 22:36.040
And the last one.

22:36.040 --> 22:37.040
And the last one.

22:37.040 --> 22:38.040
Yeah.

22:38.040 --> 22:40.040
Also the, the code here.

22:40.040 --> 22:41.040
Oh.

22:41.040 --> 22:43.040
The QR code to test the node to test host Z.

22:43.040 --> 22:45.040
And the last one is the Coscop.

22:45.040 --> 22:46.040
Yeah.

22:46.040 --> 22:49.040
Coscop is our open source Taiwan foundations.

22:49.040 --> 22:51.040
And we are called for.

22:51.040 --> 22:54.040
Talks in August of this year.

22:54.040 --> 22:55.040
We're coming to Taiwan.

22:55.040 --> 22:57.040
If you, you guys want to visit.

22:57.040 --> 22:58.040
Yeah.

22:58.040 --> 22:59.040
Yeah.

22:59.040 --> 23:00.040
Yeah. And so thank you.

23:00.040 --> 23:03.040
No, please start our project.

23:03.040 --> 23:04.040
Yeah.

23:04.040 --> 23:06.040
And thank you Coscop to finance the.

23:06.040 --> 23:07.040
Yeah.

23:07.040 --> 23:08.040
Yeah.

23:08.040 --> 23:09.040
To first them.

23:09.040 --> 23:10.040
A lot of them.

23:10.040 --> 23:12.040
Pondigion support me to come here.

23:12.040 --> 23:13.040
Yeah.

23:13.040 --> 23:14.040
Any questions?

23:14.040 --> 23:15.040
Thank you.

23:15.040 --> 23:17.040
Thank you.

23:17.040 --> 23:19.040
Thank you.

23:19.040 --> 23:20.040
Thank you.

23:20.040 --> 23:21.040
Thank you.

23:21.040 --> 23:22.040
Thank you.

23:22.040 --> 23:23.040
Thank you.

23:23.040 --> 23:24.040
Thank you.

23:24.040 --> 23:26.040
Thank you.

23:27.040 --> 23:29.040
Hi. Thank you for the talk.

23:29.040 --> 23:30.040
It was really interesting.

23:30.040 --> 23:32.040
I'm wondering if you're not.

23:32.040 --> 23:35.040
If you can run with us dependencies.

23:35.040 --> 23:36.040
How do you under.

23:36.040 --> 23:39.040
Uh, message generation going from.

23:39.040 --> 23:40.040
There is a question.

23:40.040 --> 23:41.040
There is a question.

23:41.040 --> 23:43.040
Actually, we almost.

23:43.040 --> 23:44.040
Hack.

23:44.040 --> 23:45.040
Love.

23:45.040 --> 23:46.040
Message schema.

23:46.040 --> 23:47.040
La Cogian.

23:47.040 --> 23:49.040
The message generations.

23:49.040 --> 23:52.040
And the, the rich for trade systems.

23:52.040 --> 23:54.040
Let can easily support the go by things.

23:54.040 --> 23:56.040
And the price and buy things.

23:56.040 --> 23:58.040
And the, the trade like the polo path.

23:58.040 --> 24:00.040
Any serializations.

24:00.040 --> 24:02.040
Comedy using rust.

24:02.040 --> 24:03.040
Framework.

24:03.040 --> 24:06.040
So we almost have all the season.

24:06.040 --> 24:09.040
So just basically it's.

24:09.040 --> 24:13.040
Uh, implementation of what's ideal, but in rest with.

24:13.040 --> 24:15.040
Uh, back ends that we can plug.

24:15.040 --> 24:16.040
Yeah.

24:16.040 --> 24:21.040
Question one more question.

24:21.040 --> 24:23.040
Um, I think we finally fix.

24:23.040 --> 24:24.040
Roth.

24:24.040 --> 24:27.040
And the only thing I think we really should get rid of CDR.

24:27.040 --> 24:31.040
And then just go to Fledberg or something that's serial copy.

24:31.040 --> 24:34.040
And then I guess we can outperform Dora and the corporate even.

24:34.040 --> 24:35.040
Yes.

24:35.040 --> 24:36.040
Yes.

24:36.040 --> 24:37.040
Yes.

24:37.040 --> 24:38.040
Thank you.

24:38.040 --> 24:42.040
Um.

24:42.040 --> 24:43.040
Uh, just one more.

24:43.040 --> 24:44.040
One.

24:44.040 --> 24:45.040
Yeah.

24:45.040 --> 24:46.040
Just out of curiosity.

24:46.040 --> 24:48.040
You said you're missing.

24:48.040 --> 24:50.040
Uh, a fox club format support.

24:50.040 --> 24:51.040
What do you mean by that?

24:51.040 --> 24:54.040
It's like M caps or something else.

24:54.040 --> 24:56.040
Uh, is open for discussions.

24:56.040 --> 25:00.040
Of course, we can make it support the the rust to fall back.

25:00.040 --> 25:03.040
But I'd like to put a provided support for native.

25:03.040 --> 25:05.040
First graph message.

25:05.040 --> 25:07.040
I would I would like to do so.

25:15.040 --> 25:16.040
Thank you.

25:16.040 --> 25:17.040
Thank you.