WEBVTT

00:00.000 --> 00:11.000
Next up is Thomas on research data line which will be for P.C.

00:11.000 --> 00:12.000
Yes, okay.

00:12.000 --> 00:14.000
I hope you understand that.

00:14.000 --> 00:16.000
We're not going to stop.

00:16.000 --> 00:18.000
Okay, so idea for this.

00:18.000 --> 00:20.000
I'm not going to go.

00:20.000 --> 00:22.000
I'm going to go in a search.

00:22.000 --> 00:24.000
I'm 15 years ago.

00:25.000 --> 00:27.000
We had some technical report on that.

00:27.000 --> 00:29.000
And we also did some case.

00:29.000 --> 00:32.000
That was I was in the system for a minute in the letter.

00:32.000 --> 00:34.000
But it was really easy.

00:34.000 --> 00:36.000
I'm going to explain this for you.

00:36.000 --> 00:38.000
And I'm going to show you the structure.

00:38.000 --> 00:39.000
You're going to work on easy.

00:39.000 --> 00:41.000
That you may be using the device.

00:41.000 --> 00:42.000
Please.

00:42.000 --> 00:43.000
We can do this.

00:43.000 --> 00:44.000
So right.

00:44.000 --> 00:45.000
This.

00:45.000 --> 00:46.000
I'm going to go.

00:46.000 --> 00:47.000
So.

00:47.000 --> 00:48.000
So.

00:48.000 --> 00:49.000
So.

00:49.000 --> 00:50.000
So.

00:50.000 --> 00:54.000
So.

00:54.000 --> 00:59.000
So.

00:59.000 --> 01:00.000
And.

01:00.000 --> 01:03.000
So.

01:03.000 --> 01:06.000
So.

01:06.000 --> 01:13.000
So.

01:13.000 --> 01:18.000
So.

01:18.000 --> 01:29.000
But actually the research of the one that has some kind of creative help, so I don't

01:29.000 --> 01:30.000
know, it's brilliant.

01:30.000 --> 01:36.000
And I can also just, for the most fun, you know, fun stuff.

01:36.000 --> 01:38.000
Search there.

01:38.000 --> 01:44.000
So, about there's more products, so I think this is such an instrument.

01:44.000 --> 01:47.000
Not really, they're not as familiar as it is.

01:47.000 --> 01:50.000
So, if you go out, look at that.

01:50.000 --> 01:54.000
If you're not going to go out, you're still a, I don't know, whatever it is.

01:54.000 --> 02:00.000
You're in the post of Professor, you rarely find anything about research there.

02:00.000 --> 02:04.000
And I would guess it's the same as all the side values you use.

02:04.000 --> 02:07.000
You have to write the statement that you've done.

02:07.000 --> 02:12.000
You never really get anything that you've done.

02:12.000 --> 02:17.000
Also, it's very often fun that any organization, because it has some training,

02:17.000 --> 02:21.000
and some policies, but not much more than that.

02:21.000 --> 02:24.000
And of course, of course, it was just fun to what they do,

02:24.000 --> 02:30.000
and you really do the many more to satisfy the funders,

02:30.000 --> 02:32.000
and how they just require this.

02:32.000 --> 02:36.000
But there's actually more products through researches.

02:36.000 --> 02:39.000
So, they have to deal with many different IT systems.

02:39.000 --> 02:41.000
They have to deal with all that products.

02:41.000 --> 02:46.000
They need to see, now, they just remain in different sorts of areas.

02:46.000 --> 02:49.000
How does it develop for the also happening?

02:49.000 --> 02:53.000
Please, intergenity of the architectures.

02:53.000 --> 02:57.000
And then, so whatever architectures or gentlemen,

02:57.000 --> 03:02.000
in search of an instrument, it kind of has to manage the goods,

03:02.000 --> 03:06.000
the goods, the data, and such that this is no longer a project.

03:06.000 --> 03:11.000
Moving data, and then, also, when the urban system,

03:11.000 --> 03:12.000
I can actually proceed to this.

03:12.000 --> 03:16.000
Very difficult storage space, and from the right,

03:16.000 --> 03:17.000
it's important for this.

03:17.000 --> 03:20.000
It doesn't make any noise, either.

03:20.000 --> 03:25.000
So, now, if you can do the picture, you can do it immediately.

03:25.000 --> 03:30.000
So, you can buy it, but then, it's not necessarily to have a third of all,

03:30.000 --> 03:32.000
but it's very inclusive.

03:32.000 --> 03:35.000
You can use many different kinds of things.

03:35.000 --> 03:37.000
You can just have to do anything about it.

03:37.000 --> 03:40.000
You don't have to install it, and you can do that.

03:40.000 --> 03:45.000
And the picture was had this all in different IT systems,

03:45.000 --> 03:48.000
because you have to do it, and they were all in system.

03:48.000 --> 03:52.000
Also, I mean, I mean, the tools and actions you know,

03:52.000 --> 03:56.000
something that goes very quickly in architecture.

03:56.000 --> 04:00.000
You have the benefits available for that.

04:00.000 --> 04:06.000
But the question is, how do we have the mentioned data?

04:06.000 --> 04:12.000
So, the question also, how do we get this?

04:12.000 --> 04:14.000
You want this data?

04:14.000 --> 04:17.000
You can access data, and you can use it.

04:17.000 --> 04:19.000
Now, you don't have to do that.

04:19.000 --> 04:21.000
You have to insert this.

04:21.000 --> 04:23.000
You want to avoid all these new data,

04:23.000 --> 04:26.000
but they don't manage to operate.

04:26.000 --> 04:29.000
And, yeah, so, why you would like to use easy,

04:29.000 --> 04:32.000
because everyone's already used it.

04:32.000 --> 04:33.000
No, no, no.

04:33.000 --> 04:37.000
And, as I think easy to watch the races,

04:37.000 --> 04:39.000
what is it?

04:39.000 --> 04:41.000
As an easy example,

04:41.000 --> 04:45.000
there is a thing of it that's a three-dimensional

04:45.000 --> 04:48.000
site to fix up these conditions.

04:48.000 --> 04:52.000
I mean, you know, for the two-dimensional techniques,

04:53.000 --> 04:58.000
you can use it, or use it as a site to fix up this condition.

04:58.000 --> 05:01.000
You have to use it as a single product.

05:01.000 --> 05:04.000
And, you have to use it from the same method.

05:04.000 --> 05:07.000
You can use it from any system.

05:07.000 --> 05:12.000
And, if you can use it, you can use it,

05:12.000 --> 05:15.000
and get a maximum source of the data,

05:15.000 --> 05:20.000
and you can use it from your device.

05:20.000 --> 05:23.000
So, we don't want to do that at all.

05:23.000 --> 05:25.000
The problem is that you use our site there.

05:25.000 --> 05:27.000
My business system again again.

05:27.000 --> 05:29.000
Now, if you want to look together,

05:29.000 --> 05:30.000
there's very good business.

05:30.000 --> 05:35.000
So, I'm attempting to use it as a three-dimensional,

05:35.000 --> 05:38.000
or if you want to use it as a business.

05:38.000 --> 05:43.000
But also, it allows us to put it right on it.

05:43.000 --> 05:45.000
Okay.

05:46.000 --> 05:49.000
So, at least the structure values in the left,

05:49.000 --> 05:52.000
actually, when you see this before.

05:52.000 --> 05:55.000
So, we don't have to have a source of the S,

05:55.000 --> 05:59.000
or something like this, and we can use it in the middle,

05:59.000 --> 06:02.000
and then change the system to not work it.

06:02.000 --> 06:03.000
Sorry?

06:03.000 --> 06:05.000
Okay, now.

06:05.000 --> 06:07.000
Okay, I'm sorry.

06:07.000 --> 06:09.000
And then, in the middle,

06:09.000 --> 06:11.000
they have to come for the business.

06:11.000 --> 06:14.000
We use again to for that.

06:14.000 --> 06:17.000
And so, that allows us to, at the top layer,

06:17.000 --> 06:20.000
we don't have to care about all these different Linux distributions.

06:20.000 --> 06:22.000
And here, the file estimates,

06:22.000 --> 06:24.000
the last I want to mention is that

06:24.000 --> 06:28.000
there, we use the S to distribute the software across the world.

06:28.000 --> 06:31.000
It's a proven solution that scares very well,

06:31.000 --> 06:35.000
and you can get quickly access to it.

06:35.000 --> 06:41.000
So, once we add the software package on our sample server,

06:42.000 --> 06:45.000
it comes within minutes of the day that everybody.

06:45.000 --> 06:48.000
So, that's very convenient.

06:48.000 --> 06:49.000
Okay.

06:49.000 --> 06:55.000
So, here's a little bit different way of showing this.

06:55.000 --> 06:59.000
And so, of course, we don't want to extend the CNN software there,

06:59.000 --> 07:04.000
because then you would have to do this in many packages.

07:04.000 --> 07:08.000
It's much better if you do this here in the comfort layer.

07:08.000 --> 07:13.000
So, where we have to sort of again, to layer.

07:13.000 --> 07:17.000
So, the assumption is that all, let's say,

07:17.000 --> 07:20.000
already made it all, but most of the data access

07:20.000 --> 07:25.000
goes through the comfort layer, and then to the data file system.

07:25.000 --> 07:31.000
And so, we have, example, open functions,

07:31.000 --> 07:33.000
read, write, close, and so on.

07:33.000 --> 07:36.000
And these are all part of GNIPC.

07:36.000 --> 07:40.000
So, if we do something with that, then change there,

07:40.000 --> 07:44.000
apply to all the software package.

07:44.000 --> 07:45.000
So, how can we change it?

07:45.000 --> 07:49.000
So, we could of course, because we build GNIPC from source,

07:49.000 --> 07:51.000
we could directly change GNIPC.

07:51.000 --> 07:54.000
So, that's more of the advantages,

07:54.000 --> 07:57.000
really transparent for you,

07:57.000 --> 07:59.000
and they don't need to change anything.

07:59.000 --> 08:03.000
But, also, the problem is that it's always on,

08:03.000 --> 08:06.000
whether you want to need it or not,

08:06.000 --> 08:12.000
and they also may have some on the consequences.

08:12.000 --> 08:18.000
And, yeah, you also need to change what

08:18.000 --> 08:20.000
you already should within you.

08:20.000 --> 08:23.000
So, maybe that's also what you don't want.

08:23.000 --> 08:27.000
And there's a way could be that you read functions,

08:27.000 --> 08:29.000
and then you use the pre-load.

08:30.000 --> 08:33.000
Of course, the advantage of that word would be that,

08:33.000 --> 08:35.000
to keep the default GNIPC,

08:35.000 --> 08:39.000
and it could be easily switched on off by users.

08:39.000 --> 08:45.000
The disadvantages we have to sort of adjust every run for this.

08:45.000 --> 08:48.000
So, and you kind of make this very transparent.

08:48.000 --> 08:51.000
And, yeah, and of course, it can also, again,

08:51.000 --> 08:54.000
create conflicts, if you set the slow release,

08:54.000 --> 08:58.000
because then we'll apply to all codes,

08:58.000 --> 09:02.000
we run, maybe they don't, maybe they've taken all the codes

09:02.000 --> 09:04.000
that the programs we execute,

09:04.000 --> 09:06.000
that are not part of eerie,

09:06.000 --> 09:09.000
but we're going to come from systems like swear or command,

09:09.000 --> 09:10.000
and so on.

09:10.000 --> 09:14.000
For prototype, we do this,

09:14.000 --> 09:17.000
grabbing a functions and use the pre-load.

09:17.000 --> 09:21.000
So, now some ideas what we could actually wrap

09:21.000 --> 09:23.000
as to what we could do with that.

09:23.000 --> 09:26.000
So, we could log information for codes,

09:26.000 --> 09:29.000
and it's like open access.

09:29.000 --> 09:31.000
So, then later on, once we have a log,

09:31.000 --> 09:35.000
we can post-process that and create data flow grounds.

09:35.000 --> 09:41.000
We could also enable that we use remote data directly.

09:41.000 --> 09:44.000
So, we don't have to manually download them,

09:44.000 --> 09:46.000
and then open them, and use them,

09:46.000 --> 09:50.000
but we can directly use them.

09:50.000 --> 09:54.000
And we can also define some kind of virtual data infrastructure.

09:54.000 --> 09:55.000
We just have to say, okay,

09:55.000 --> 09:58.000
so this data will be belongs to this,

09:58.000 --> 10:00.000
what I want to use,

10:00.000 --> 10:02.000
some kind of view over the namespace,

10:02.000 --> 10:04.000
and then some runtime and choose

10:04.000 --> 10:08.000
that the data is there as accessible and drawn.

10:08.000 --> 10:10.000
Okay, so now,

10:10.000 --> 10:16.000
we just want to go through this idea and show what is needed to do,

10:16.000 --> 10:19.000
it's an example for open.

10:19.000 --> 10:21.000
So, if we register,

10:21.000 --> 10:24.000
we can just print something and do a log,

10:24.000 --> 10:28.000
and then we have to call the actual open function.

10:28.000 --> 10:30.000
So, it's not so difficult.

10:30.000 --> 10:32.000
The compilation is also not so difficult,

10:32.000 --> 10:34.000
and then to use this,

10:34.000 --> 10:36.000
we can just use any pre-load,

10:36.000 --> 10:38.000
and then, in fact,

10:38.000 --> 10:41.000
some of the cat may be not very scientifically interesting,

10:41.000 --> 10:43.000
but yeah.

10:43.000 --> 10:47.000
And then, what we get is we get some log lines,

10:47.000 --> 10:51.000
and we can have many information in there,

10:51.000 --> 10:53.000
and then, basically, what then we have,

10:53.000 --> 10:55.000
as we get something like, okay,

10:55.000 --> 10:56.000
there was a program,

10:56.000 --> 10:58.000
it produced some image,

10:58.000 --> 10:59.000
and then, maybe,

10:59.000 --> 11:01.000
this image later,

11:01.000 --> 11:04.000
we used to make a publication,

11:04.000 --> 11:06.000
and then, of course,

11:06.000 --> 11:09.000
we put connect,

11:09.000 --> 11:10.000
sort of,

11:10.000 --> 11:15.000
these two programs,

11:15.000 --> 11:18.000
and we'll wire the ed files.

11:20.000 --> 11:22.000
Okay, there are many different use cases,

11:22.000 --> 11:23.000
what we can do,

11:23.000 --> 11:24.000
so we can, sort of,

11:24.000 --> 11:25.000
automatically,

11:25.000 --> 11:27.000
we have the image and the end,

11:27.000 --> 11:30.000
we can start from the data source,

11:30.000 --> 11:33.000
and get a full buffer of what we did.

11:33.000 --> 11:34.000
Yeah.

11:34.000 --> 11:35.000
And of course,

11:35.000 --> 11:36.000
if we do this,

11:36.000 --> 11:37.000
let's say,

11:37.000 --> 11:38.000
not this already,

11:38.000 --> 11:39.000
we have,

11:39.000 --> 11:40.000
the workflow,

11:40.000 --> 11:42.000
we can also generate the workflow of that,

11:42.000 --> 11:43.000
and then we can use that,

11:43.000 --> 11:45.000
and copy the workflow,

11:45.000 --> 11:46.000
managements of,

11:46.000 --> 11:47.000
like,

11:47.000 --> 11:48.000
next close,

11:48.000 --> 11:49.000
make an all this,

11:49.000 --> 11:50.000
yeah,

11:50.000 --> 11:51.000
and yeah.

11:51.000 --> 11:53.000
Another interesting use case,

11:53.000 --> 11:54.000
could be that,

11:54.000 --> 11:57.000
maybe if many data files we wanted to analyze,

11:57.000 --> 12:00.000
but we don't know if we actually use them all,

12:00.000 --> 12:04.000
so we could check if we have already used all these data files.

12:04.000 --> 12:06.000
Okay,

12:06.000 --> 12:07.000
so,

12:08.000 --> 12:09.000
go back in time,

12:09.000 --> 12:11.000
because if we do a lot of times them,

12:11.000 --> 12:13.000
we could check what did we do on Monday,

12:13.000 --> 12:14.000
because,

12:14.000 --> 12:15.000
maybe on Monday,

12:15.000 --> 12:16.000
I had a good idea,

12:16.000 --> 12:17.000
and we learned to check this easily,

12:17.000 --> 12:20.000
and we don't have to lock this manually.

12:22.000 --> 12:23.000
There are some ideas,

12:23.000 --> 12:24.000
when I worked on this,

12:24.000 --> 12:26.000
so it's been a negative sort of spin,

12:26.000 --> 12:28.000
it was filling up,

12:28.000 --> 12:32.000
start times of programs that need a lot of libraries,

12:32.000 --> 12:34.000
and we could also use it for this,

12:34.000 --> 12:35.000
and of course,

12:35.000 --> 12:38.000
and we also interesting is that we could actually use it also,

12:38.000 --> 12:40.000
for easy itself,

12:40.000 --> 12:41.000
when we build software,

12:41.000 --> 12:43.000
it's very important that we only build,

12:43.000 --> 12:44.000
again,

12:44.000 --> 12:46.000
software that is already in ease,

12:46.000 --> 12:47.000
when the software layer,

12:47.000 --> 12:49.000
or in the compatibility layer,

12:49.000 --> 12:51.000
not elsewhere,

12:51.000 --> 12:53.000
because that could then make problems,

12:53.000 --> 12:54.000
when we ship it,

12:54.000 --> 12:56.000
and maybe the software we use on the build system,

12:56.000 --> 12:58.000
it's not very user.

13:00.000 --> 13:01.000
Okay,

13:01.000 --> 13:02.000
and then, of course,

13:02.000 --> 13:04.000
we could also use this to pre-load the cache,

13:04.000 --> 13:06.000
to improve startup times.

13:07.000 --> 13:10.000
Another idea is sort of to,

13:10.000 --> 13:11.000
in a novel,

13:11.000 --> 13:14.000
access to remote data directly,

13:14.000 --> 13:15.000
so,

13:15.000 --> 13:18.000
pattern would be usually that you find something interesting,

13:18.000 --> 13:19.000
you download it,

13:19.000 --> 13:21.000
and then you start using it,

13:21.000 --> 13:23.000
and to go of that would be,

13:23.000 --> 13:24.000
of course,

13:24.000 --> 13:28.000
that you sort of avoid this manual download set.

13:28.000 --> 13:30.000
And as a benefit of that,

13:30.000 --> 13:32.000
it would also be that,

13:32.000 --> 13:34.000
you make very explicit,

13:34.000 --> 13:36.000
where it's got data from.

13:36.000 --> 13:37.000
In the work event,

13:37.000 --> 13:38.000
you see that,

13:38.000 --> 13:40.000
where it got data from.

13:40.000 --> 13:42.000
And the nice thing is also,

13:42.000 --> 13:44.000
when data is associated with these,

13:44.000 --> 13:45.000
persistent alignifiers,

13:45.000 --> 13:47.000
you can get metadata from it,

13:47.000 --> 13:48.000
and then,

13:48.000 --> 13:53.000
sort of enrich the description of data flow.

13:54.000 --> 13:57.000
So, it's just an example of how this could look like,

13:57.000 --> 13:59.000
but again, for open,

13:59.000 --> 14:00.000
we could check,

14:00.000 --> 14:01.000
okay,

14:01.000 --> 14:02.000
it's just a URL.

14:02.000 --> 14:03.000
The person,

14:03.000 --> 14:04.000
you have there,

14:04.000 --> 14:05.000
then download it,

14:05.000 --> 14:06.000
and then,

14:06.000 --> 14:07.000
do the,

14:07.000 --> 14:08.000
the actual open list,

14:08.000 --> 14:10.000
sort of the local copy.

14:10.000 --> 14:11.000
And for the user,

14:11.000 --> 14:12.000
this looks,

14:12.000 --> 14:14.000
totally transparent.

14:14.000 --> 14:15.000
And,

14:15.000 --> 14:16.000
so again,

14:16.000 --> 14:17.000
if you compile this,

14:17.000 --> 14:18.000
it's,

14:18.000 --> 14:19.000
much more difficult,

14:19.000 --> 14:21.000
and then you sort of,

14:21.000 --> 14:22.000
maybe have some option,

14:22.000 --> 14:23.000
that they can say,

14:23.000 --> 14:24.000
okay,

14:24.000 --> 14:25.000
so there's some space,

14:25.000 --> 14:27.000
they can make a copy of this.

14:27.000 --> 14:28.000
And then,

14:28.000 --> 14:29.000
we have sort of,

14:29.000 --> 14:30.000
now here,

14:30.000 --> 14:31.000
a little command,

14:31.000 --> 14:32.000
we say,

14:32.000 --> 14:33.000
okay,

14:33.000 --> 14:34.000
so it's really,

14:34.000 --> 14:35.000
I run,

14:35.000 --> 14:36.000
and then,

14:36.000 --> 14:37.000
just a standard command,

14:37.000 --> 14:38.000
this URL looks very long,

14:38.000 --> 14:39.000
yeah.

14:39.000 --> 14:40.000
And,

14:40.000 --> 14:42.000
so what we could think of,

14:42.000 --> 14:44.000
is that to improve this image,

14:44.000 --> 14:46.000
that we actually specify the,

14:46.000 --> 14:47.000
the UI,

14:47.000 --> 14:48.000
so for them,

14:48.000 --> 14:49.000
you have to improve it,

14:49.000 --> 14:50.000
the implementation,

14:50.000 --> 14:52.000
but this could also work.

14:52.000 --> 14:54.000
Okay,

14:54.000 --> 14:56.000
so this actually works surprisingly well,

14:56.000 --> 14:58.000
although not for all commands,

14:58.000 --> 14:59.000
but I tested this,

14:59.000 --> 15:01.000
but how it didn't work,

15:01.000 --> 15:03.000
and all at the moment,

15:03.000 --> 15:04.000
only works for red excess,

15:04.000 --> 15:06.000
but also works for bright.

15:06.000 --> 15:07.000
So,

15:07.000 --> 15:08.000
for bright,

15:08.000 --> 15:09.000
what you would need,

15:09.000 --> 15:11.000
is some kind of API,

15:11.000 --> 15:12.000
the background,

15:12.000 --> 15:15.000
that sort of supports that you actually write in.

15:15.000 --> 15:16.000
So,

15:16.000 --> 15:18.000
and you probably would do the upload,

15:18.000 --> 15:19.000
when you,

15:19.000 --> 15:21.000
the file is closed.

15:21.000 --> 15:23.000
Okay,

15:24.000 --> 15:28.000
maybe I skipped the rest of that.

15:28.000 --> 15:29.000
So,

15:29.000 --> 15:32.000
then sort of the last idea was that,

15:32.000 --> 15:36.000
you defined some kind of virtual data infrastructure.

15:36.000 --> 15:39.000
And what you could do is that you,

15:39.000 --> 15:42.000
maybe say you define some namespace,

15:42.000 --> 15:43.000
and maybe some labor,

15:43.000 --> 15:46.000
so it identifies that you want to use.

15:46.000 --> 15:47.000
And,

15:47.000 --> 15:49.000
the searcher would then,

15:49.000 --> 15:51.000
only give it a name,

15:52.000 --> 15:55.000
and register some of these data files,

15:55.000 --> 15:57.000
or maybe even the words,

15:57.000 --> 16:00.000
whether data resides.

16:00.000 --> 16:01.000
And then,

16:01.000 --> 16:02.000
sometimes,

16:02.000 --> 16:05.000
runtime would figure out where the files actually stored.

16:05.000 --> 16:06.000
This is already local,

16:06.000 --> 16:08.000
or this is remote,

16:08.000 --> 16:10.000
and it has to be downloaded.

16:10.000 --> 16:11.000
And then,

16:11.000 --> 16:12.000
because many things,

16:12.000 --> 16:14.000
or all these basic,

16:14.000 --> 16:16.000
based on HTTP,

16:16.000 --> 16:18.000
we can also redirect

16:18.000 --> 16:20.000
to different source,

16:21.000 --> 16:24.000
and we can do much more of that.

16:24.000 --> 16:26.000
And so,

16:26.000 --> 16:27.000
what we did,

16:27.000 --> 16:28.000
so,

16:28.000 --> 16:29.000
in the first step,

16:29.000 --> 16:32.000
we created some commands,

16:32.000 --> 16:34.000
they can create some of these namespace,

16:34.000 --> 16:35.000
you can list them,

16:35.000 --> 16:37.000
and you can upload files.

16:37.000 --> 16:38.000
And,

16:38.000 --> 16:39.000
so,

16:39.000 --> 16:41.000
there we also sometimes,

16:41.000 --> 16:42.000
two,

16:42.000 --> 16:43.000
you know,

16:43.000 --> 16:45.000
they can manage all those,

16:45.000 --> 16:46.000
and then,

16:46.000 --> 16:48.000
you can get a link,

16:49.000 --> 16:50.000
and,

16:50.000 --> 16:52.000
to then,

16:52.000 --> 16:55.000
just sort of back under the data,

16:55.000 --> 16:56.000
and then,

16:56.000 --> 16:57.000
you can just say head,

16:57.000 --> 16:59.000
and then you see sort of the output of that.

16:59.000 --> 17:00.000
And,

17:00.000 --> 17:03.000
but this really is just basic proof of concept.

17:03.000 --> 17:05.000
So, what's the status?

17:05.000 --> 17:06.000
We have some,

17:06.000 --> 17:08.000
kind of prototype implementation.

17:08.000 --> 17:09.000
We have some,

17:09.000 --> 17:11.000
command line tool,

17:11.000 --> 17:12.000
with the eye,

17:12.000 --> 17:13.000
which,

17:13.000 --> 17:15.000
you can use the run things,

17:15.000 --> 17:16.000
also,

17:16.000 --> 17:18.000
to manipulate this,

17:18.000 --> 17:20.000
virtual data infrastructure,

17:20.000 --> 17:23.000
and to add files to that,

17:23.000 --> 17:24.000
and it's all,

17:24.000 --> 17:25.000
it's open source,

17:25.000 --> 17:27.000
it's a processor,

17:27.000 --> 17:29.000
it's built-in source in less than a minute,

17:29.000 --> 17:30.000
it's very easy,

17:30.000 --> 17:32.000
it could be shipped with easy,

17:32.000 --> 17:33.000
it's not shipped easy,

17:33.000 --> 17:34.000
but could be,

17:34.000 --> 17:35.000
in principle,

17:35.000 --> 17:36.000
and we have some,

17:36.000 --> 17:37.000
kind of,

17:37.000 --> 17:39.000
server infrastructure for front end,

17:39.000 --> 17:40.000
and back end,

17:40.000 --> 17:42.000
so that the author's nice,

17:42.000 --> 17:43.000
is to use it,

17:43.000 --> 17:46.000
with one piece of one line,

17:46.000 --> 17:47.000
okay.

17:47.000 --> 17:48.000
So,

17:48.000 --> 17:50.000
outlooks of what we could do

17:50.000 --> 17:51.000
is the,

17:51.000 --> 17:52.000
with these data flowgraster,

17:52.000 --> 17:54.000
we could actually export it,

17:54.000 --> 17:56.000
through tools like next flows,

17:56.000 --> 17:57.000
make,

17:57.000 --> 17:59.000
make nice,

17:59.000 --> 18:01.000
with the actions of this work,

18:01.000 --> 18:03.000
and so that you can create

18:03.000 --> 18:05.000
the picture with light,

18:05.000 --> 18:07.000
and then you can edit to your publication,

18:07.000 --> 18:09.000
we could of course,

18:09.000 --> 18:11.000
could intercept more,

18:11.000 --> 18:18.200
functions and yeah. So what I learned is the next talk will have something

18:18.200 --> 18:22.920
audible throughout for engines and they also use Iorots. So interfacing this

18:22.920 --> 18:26.800
was as a back-end quickly very good because then the problem is a little bit

18:26.800 --> 18:33.560
that how do we access sort of the data file system and the remote system.

18:33.560 --> 18:39.120
And I think this could be done very well with this what the next speaker

18:39.120 --> 18:46.360
probably tell about. Okay summary so working with the search that is not

18:46.360 --> 18:55.040
too easy. We have two told with a couple of today a lot of data to create

18:55.040 --> 19:02.440
this data work progress and then for effortlessly accessing remote data we have

19:02.440 --> 19:10.240
some prototype and with that. So let's say if this vision becomes fully implemented

19:10.240 --> 19:13.000
then I think the researchers they can focus on working the

19:13.000 --> 19:20.600
data and don't have to some tools take care of all the logistics for the data.

19:20.600 --> 19:28.200
Okay some resources if you want to look up more about the original reporter

19:28.200 --> 19:32.960
and some case study so of course easy if you want to don't know what easy

19:32.960 --> 19:38.480
you can look it up. So if you have a slacker you can either join everything

19:38.480 --> 19:46.760
in this open source or to most of the development of the user is funded by

19:46.760 --> 19:54.560
your HPC instead of excellent, excellent, smart, extra and all the codes for this talk.

19:54.560 --> 20:09.560
Thank you Thomas. You have plenty for a couple of questions.

20:09.560 --> 20:38.200
Do you see a lot of things? Yeah. So yeah so if you're right, okay so the

20:38.200 --> 20:48.520
question is if I expect that we need locking for writing the model, right, so if

20:48.520 --> 20:52.880
there could be multiple vertices I think there need to be some there need to be some

20:52.880 --> 21:13.880
synchronization among the writers.

21:13.880 --> 21:24.880
I don't really know. Okay so the question is if sort of might provide a bit of

21:24.880 --> 21:32.160
coordinate, synchronize, right. I don't know, I would expect you need to have an

21:32.160 --> 21:41.120
like this. So I have there was some work like maybe 25 years ago on implementing

21:41.120 --> 21:48.120
a sort of kind of virtual, this is which has memory and so there were lots of development

21:48.120 --> 21:54.560
of different ways to synchronize it with different consistency models and maybe one could

21:54.560 --> 22:01.240
look into this to see if there are supposed to be questions, how to implement this efficiently

22:01.240 --> 22:08.240
and thank you.

22:08.240 --> 22:16.240
I have one maybe used to go on. Why has anyone 12 this year?

22:16.240 --> 22:26.240
No, it's a stupid idea, I don't know. It seems like a simple concept. I don't know.

22:26.240 --> 22:47.240
Does anyone have an answer?

22:48.240 --> 22:55.240
So the question is if all the data is lost, those into some kind of lots work, some

22:55.240 --> 23:01.240
notebook or so, where it would keep normally nodes in a let or so.

23:01.240 --> 23:08.040
Oh yes, you could do this. So actually I would think that maybe if you just want to focus

23:08.040 --> 23:14.240
on the fun part, yeah, not on all this logging and keeping nodes, one could use it, maybe

23:14.240 --> 23:21.240
if I can. I think that we can do something like this with IOS because I don't

23:21.240 --> 23:28.240
have such a lot of post-expression systems and we can probably use the metadata IOS to

23:28.240 --> 23:33.240
bring it to the logs, certain data and choose because the metadata IOS actually has the

23:33.240 --> 23:40.240
data.

23:40.240 --> 23:48.240
So the comment is that one could probably use IOS because they have stored information

23:48.240 --> 24:04.240
database and then, so I can watch the objects that are, yeah.

24:04.240 --> 24:19.240
Yeah, I don't think that's the data, but I don't think that's the data.

24:19.240 --> 24:29.240
I don't think that's the data, but I don't think that's the data.

24:29.240 --> 24:45.240
I don't think that's the data, but I don't think that's the data, but I don't think

24:45.240 --> 24:50.240
that's the data.

24:50.240 --> 24:59.240
Okay, so I here quickly that if you use IOS back end, you just could complain that

24:59.240 --> 25:05.240
the work also has to bring it in and get it out, so if you have a layer on top of that

25:05.240 --> 25:09.240
that sort of makes the transparent that you don't have to do this, it just works like

25:09.240 --> 25:17.240
this normal program that just helps in using IOS. But then, okay, the problem is maybe

25:17.240 --> 25:21.240
a little bit, if you have very large data, that's how to handle this. And if you do

25:21.240 --> 25:26.240
to do this then, it's an open call, that could be maybe not a best call, but you could

25:26.240 --> 25:32.240
automatically do it with just a weak call and just say, okay, if they know that the data

25:32.240 --> 25:40.240
in IOS in a database, you can access it, you can maybe just use the weak call and all

25:40.240 --> 25:43.240
of right doors.

25:43.240 --> 25:49.240
Finally, yeah, just to come and keep you mentioned in the last part of the other similar

25:49.240 --> 25:53.240
efforts, I believe that I don't want to stay there, just because people are learning

25:53.240 --> 25:59.240
this, something from the system, or bring it to the platform for analysis that

25:59.240 --> 26:01.240
that lets you get that right.

26:01.240 --> 26:04.240
And what's this? I don't want to stay turn around with you.

26:04.240 --> 26:06.240
That's from the TSCS?

26:07.240 --> 26:12.240
No, sweet thing to say is, sweet data sends it out, okay, what's the name of the

26:12.240 --> 26:13.240
rank call?

26:13.240 --> 26:15.240
One detail, okay.

26:15.240 --> 26:18.240
Okay.

26:18.240 --> 26:20.240
Okay.

26:20.240 --> 26:24.240
All right, yeah, just wrap up, thank you so much.