Structured-Wide-Area-Programming.PzGo3w2iqcs.Jayadev-Misra-unity.srt.txt

字幕記錄


00:00
I
00:21
and if you see special pleasure mr.
00:25
because use one of my own former
00:26
teachers and given today the things I
00:30
learned from him and distributed
00:32
computing about 20 years ago I find our
00:34
program what the modern / was still just
00:39
waiting to be up after time that I can I
00:42
can benefit from them and hopefully make
00:43
sense of them in practice I'll jellied
00:46
over to Professor miss try to talk about
00:49
his new work the orc language and in
00:52
particular with the topic I think the
00:54
title is structured wide-area program
01:01
thank you hun unless it's always a
01:04
pleasure to see when one of Judy's have
01:09
done well and you still have done very
01:11
well I'm very glad to be here and as
01:15
Manila has diplomatically pointed out
01:17
they think that I'm going to talk about
01:19
now since the navigation will have no
01:21
application for the next twenty year now
01:26
I is that I I will hope to see how it's
01:31
a business before I die and I'm not
01:34
planning to live with more let me let me
01:42
start with not going to get back like
01:48
this all the time I think but this path
01:54
which is the whole example I must an
01:57
honest anybody's chair
02:20
yes ma'am written in my life as you can
02:26
see it's a very short program two or
02:28
three line and let's run the program I
02:31
won't tell you what it does but let's
02:33
run it and what it's going to do a
02:37
search and let's sort for someone here
02:43
so I'm not going to know when it goes
02:46
away in say what you say okay gotcha
03:07
thank you okay a little program that
03:11
Iran and what it did was to search both
03:15
yahoo and google at the same time but
03:17
that phrase that I couldn't I couldn't
03:19
enjoy it whatever whatever site came up
03:24
with the first set of answers it out put
03:27
those answer and it out put them in a
03:30
particular form taking out the hyperlink
03:33
and just stick them in effect and only
03:35
the first line and such thing the point
03:39
I want to make is that if you describe
03:43
this problem to someone you know
03:46
independently they will say it's a very
03:47
simple problem you searched both sides
03:49
and whoever comes up with answer first
03:51
you output that answer but if you
03:53
actually go and write this program in
03:56
java language it will be a huge
03:59
undertaking and i wanted to change that
04:01
and this is the kind of program that i
04:04
would like to write it's about four
04:06
lines and it says you dump someone for a
04:10
search term and then you do this oh yeah
04:13
who are you doing and where yahoo and
04:17
google are defined are in this include
04:19
in the file yahoo and the links to some
04:24
the link and put away is how we can move
04:31
what their capabilities are and what we
04:34
have achieved in the last few years and
04:37
actually solve it come let me let me
04:45
take one more just one more these please
04:49
let's make it a little bigger you sort
04:55
of see
05:02
there is a website tomorrow Eliza Eliza
05:07
was sort of a program written in the 60s
05:10
and it take a psychoanalyst you could
05:15
give it a sentence and who roughly
05:18
speaking Tamil hip sentence of play back
05:20
to you in a min while sounding
05:22
intelligent of pseudo intelligent and
05:24
people who didn't know anything about
05:26
computers that very impressed with it so
05:29
for instance here is a Liza prom how do
05:31
you do please tell me your problem and
05:33
so if i run this
05:45
with them
05:49
okay this filming a problem and let's
05:55
say what's your problem let's try
05:59
something like this
06:08
Oh
06:18
okay so it will bond with these kinds of
06:20
things I don't want to sort of talk
06:23
about Eliza here the point I want to
06:25
make is that this particular program is
06:26
now available on the web anyone can go
06:29
and ask it give it some kind of an input
06:33
and it comes back with some kind of an
06:34
output and we can leverage that program
06:38
and write a very small program to get
06:41
its effect here the program as you can
06:43
see is about this law there was all of
06:45
it nothing nothing else he Eliza site is
06:49
defined somewhere above I suppose yeah
06:54
this this particular file includes the
06:57
the path to Eliza and you write a small
07:01
program and do get the effect of Eliza
07:04
the reason I'm showing you all this is
07:07
that at one point I decided that one of
07:12
the ways people will use the internet
07:17
would be too
07:24
that currently we use the internet more
07:29
as a giant communication device we use
07:32
it to send a message or we use it to
07:35
download stuff you don't use it in a
07:38
large collaborative manner yet we don't
07:41
take its functionality and put them
07:44
together so I wanted to solve the
07:46
following problem someone said that the
07:49
Internet is a computer and I wanted to
07:52
actually make that happen so consider
07:55
for example that we have different kinds
07:58
of services available at different types
08:00
on the web let's say there is a service
08:03
that someone has written on inverting a
08:06
matrix and hear someone has written
08:08
another service that can take a
08:10
compressed file music file and
08:13
uncompressed lettin there is a service
08:16
of someone written which can check the
08:19
spelling of a word and provide a
08:22
correction I expected that in about five
08:27
years time we'll have a hundred thousand
08:29
of these services of different kinds
08:30
available the consider for a moment that
08:33
each of this service is the primitive
08:36
operation of a computer like today's
08:39
computer love add subtract multiply kind
08:41
of thing these are the primitive
08:43
operations and on top of these primitive
08:46
operations we implement a programming
08:48
language to do bigger things so for
08:53
example I just ask modify students to
08:56
write the following program which should
08:58
be about pipeline there is a site which
09:02
keeps track of which which keeps copies
09:06
of out of copyright books so you can get
09:10
Mark Twain's books at that type I forgot
09:13
I know decide if somewhere anyone know a
09:16
good look Gutenberg has lots of good
09:19
books excellent books and it keeps them
09:22
in compressed form so i would like to
09:26
write a program that will go there and
09:27
pick up the titles of five of the books
09:30
they have and prompt they use it through
09:33
one of them the user chooses one of them
09:35
and then it goes and
09:37
yep step file and gives the file to some
09:40
other service that will uncompressed a
09:42
file so we get the uncompressed file
09:45
then take that uncompressed file give it
09:47
to another service that will pick out
09:50
the first thousand words from that file
09:51
we create a new file okay we get a
09:55
smaller file take that file pick up the
09:58
first word from it and send it to a
10:01
google spool spell checker such a
10:04
service is available it's called google
10:06
spell checker and Google will spell
10:08
check that huckleberry well sure no I
10:11
don't find any huckleberry here how
10:13
could a shame if you are thinking of it
10:14
where will suggest something and then my
10:18
program will take the second word and
10:19
ask the Google spell checker to check it
10:21
so check out the first thousand words
10:24
okay this is not a very interesting
10:27
application we haven't done much but
10:29
this will give you the idea of the kinds
10:31
of things we are capable of doing today
10:33
and i would like to write programs to be
10:36
able to do this whether i want this
10:39
program to be very very short and simple
10:40
because I can explain them for you for
10:42
them simple you take it there you get
10:45
some data from there you move it there
10:46
and the whole point of being able to
10:49
write this for the whole idea behind
10:52
writing this programs in a short passage
10:54
is that we don't do any work with cheap
10:56
we take it from here and move it there
10:59
and take it from there and move it there
11:01
we don't interpret anything that's
11:03
happening in the middle we don't look at
11:05
the data and do some work ourselves in
11:07
fact if we want to add two numbers we
11:10
would follow service that adds two
11:11
numbers how can we do anything with this
11:15
what's the model what's the advantage
11:17
why not write Java programs so let's go
11:20
on this my main talk and I'll come back
11:22
to some demos in a second so here is a
11:28
simple problem that I would challenge
11:31
you to solve today contact to airline
11:34
simultaneously for price quotes let's
11:35
say I'm coming from Austin to college
11:38
and I I would like to contact as let's
11:41
say american and delta x fitted from
11:44
either if the code is at most three
11:45
hundred dollars by the ship ask if both
11:48
ports are about 300 by any ticket
11:50
other line doesn't provide a time the
11:52
quote like our wait for five minutes and
11:54
if one airline doesn't come through i'll
11:56
just buy this other one and notify me if
11:59
neither airline provides the timeless
12:01
course okay we can write it write the
12:04
specification reasonably clear in that
12:06
much space why can't we write a program
12:09
which is about that belong to do this
12:11
job because after all airlines are
12:14
already providing lip service there will
12:16
give you a quote of some kind and the
12:19
only logic involved is something about
12:21
time and just three hundred dollars and
12:25
getting something first and looking at
12:27
it and it turns out that we don't in
12:30
current languages have these facilities
12:33
it's too involved if you think of
12:36
expanding Java adding more features to
12:38
it we don't do it very well and this
12:41
will be one one of the problems that i
12:47
would like to solve so when i started
12:48
looking at this area i saw that the the
12:52
main problem is this you want to get
12:55
data from some remote services you want
12:58
to do some computation with this data
12:59
and you want to call yet other services
13:02
with the results of course we I'm not
13:06
going to do any calculations i'm going
13:08
to call other services to calculate with
13:09
the data also so all the time i am
13:13
calling services to get data and again
13:16
calling services to do something with
13:18
the data that additionally we want to do
13:22
things like this we want to call a bunch
13:24
of services at the same time because
13:27
they can be done in parallel or we may
13:30
be expecting one of those services to
13:32
fail and we want to sort of have
13:34
something else comes Olamide want to
13:38
repeatedly polar service or a stressor
13:40
is to notify me when it acquires the
13:42
appropriate data or download an
13:43
application and invoke it locally or
13:45
have a service call another service and
13:47
once you start driving down the kinds of
13:49
capabilities you need it becomes
13:51
something like 57 things that you should
13:53
have and then I wondered how do people
13:56
actually
13:58
a new good practical commercial systems
14:00
and you see all 57 features are there no
14:04
they are all written down here this you
14:06
want to do this so if you want to do
14:08
anything novel it's impossible I put
14:10
this together i can't keep all this in
14:12
my head so they will shoot challenges is
14:14
there something fundamental with which
14:17
we can build all of these things how
14:21
small should it be and this is a
14:24
challenge i put to myself and i think i
14:28
have somewhat succeeded because we have
14:30
been working on this for two years now
14:31
and we haven't been able to break it and
14:33
the answer can anyone guess how many
14:35
features you need in a language to do
14:36
this even read my abstract three okay
14:43
let's see how far we can go with three
14:50
so here are the tweet pea well this tree
14:53
is different from that tree that I just
14:54
told you there are these are the major
14:58
components of a distributed application
15:00
that you have some you should have some
15:03
method of managing persistent data so
15:06
airlines have to have their databases
15:08
and if you call them they should be able
15:12
to look up their database and put your
15:13
price or something that's not the
15:15
problem that i'm going to solve it's an
15:18
important problem it has a new meaning
15:20
in the world of the internet there are
15:22
all kinds of new data that they have a
15:25
seat I'm very interesting to search area
15:27
I am not working in that desert area
15:29
right then there is the question of
15:33
sequential computational logic does the
15:36
ticket price exceed three hundred
15:37
dollars suppose I come here and I run my
15:41
expense account through this program it
15:44
has to add up the cost of the hotel in
15:46
the rental car and airfare and other 16
15:49
so somebody has to do the addition that
15:52
shipment of computation again I'm not
15:54
solving that problem somebody else will
15:56
ever do it what I am interested in is
15:59
orchestrating the computations what does
16:02
that mean it means that you have to do a
16:07
step
16:08
before you do another step you have to
16:11
get a file from somewhere before you
16:14
start uncompressing it and before you
16:19
start doing spell check on it so there
16:21
is a sequentiality you may have to do
16:24
certain things in parallel so you can do
16:27
them simultaneously you may wish to
16:30
start several things simultaneously but
16:32
once you get a result you may want to
16:34
kill off other computations that are
16:36
going on so I am more interested in
16:39
setting up the computations and saying
16:42
that this computation consists of
16:43
calling the services and ninja services
16:46
but I'm not going to do the real world
16:49
where other words cheap as much as
16:51
possible so we learnt you for the
16:54
section I'm going to a device a language
16:58
called orc or shots for central
17:01
orchestration I also understand it
17:03
stands a horrible animal in some movie
17:05
yeah I showed a movie twice I couldn't
17:08
understand it Oh actually you understood
17:11
it I couldn't but I resist the
17:15
six-year-old explained to me that it is
17:17
true there is such a thing I trusted so
17:19
let's go on with it it's not really a
17:24
language I mean languages have to have
17:27
many things so when I say it's a
17:29
language it's not a language it really
17:31
is a set of construct concept features
17:34
you can if an overlay them on a real
17:39
language like Java which will provide
17:41
you with data structures and other such
17:42
things and you can do a lot of things
17:45
with it so right now the program that I
17:47
showed they're all in porch but then to
17:50
do anything useful like services
17:52
services may have to wait a min Java how
17:55
do you uncompress a file it may have to
17:56
wait many other and here is the first
18:02
page of the manual and that's almost
18:04
complete you know there is a second page
18:06
so I off program is based on expressions
18:09
you write an expression it's called a
18:12
goal expression and you would like to
18:14
evaluate it but just writing a long
18:17
expression will not do the job if your
18:19
program is sort of 30,000 pages long or
18:23
something so you want to modularize it
18:25
pfeifle infant definitions in it and the
18:27
goal expression will refer to some of
18:29
these definitions so that's what an or
18:31
program that's where the program is so a
18:35
gaelic specimen a bunch of vaccination
18:37
and the program execution just evaluates
18:41
this whole expression and in order to
18:44
evaluate this goal expression it falls
18:46
it called certain certain entities that
18:50
are services they will provide services
18:52
and give it a neutral name for the site
18:56
so they're a bunch of sites that i
18:59
expect are available by uncompressing a
19:03
file or checking spelling or adding two
19:05
numbers and the expression evaluation
19:10
will call this service is to get some
19:12
results and eventually to publish some
19:15
values by publish I mean as in a
19:19
functional program there is one answer
19:21
that comes out at the end there will be
19:23
many answers coming out goal expression
19:26
and those are the publications so what
19:29
happens to a publication just think of
19:31
it like it's going into the ether do we
19:33
evaluate this the value is certain but
19:36
for the moment that's what we'll do
19:40
I wish I had not written this words
19:44
temple that's all in the eyes of the
19:46
beholder one ever writes it would Dyke
19:49
Show and stormy that I often see people
19:51
here say things are very natural natural
19:55
is a word like Christian roughening
19:58
something so simple means nothing it's
20:02
the only thing i can say that language
20:04
is only three Combinator's to form
20:06
expressions and the other things are how
20:12
much theoretical I won't talk about this
20:14
but I'm really happy with this if you
20:16
are not true I would be unhappy so this
20:24
is the manual rusted of an orc
20:26
expression the ark expression comes in
20:29
two forms either it's simple all it is
20:32
from found expression a simple
20:35
expression looks like that you call a
20:39
surface let's say there is a service for
20:41
CNN and you give it a parameter D it
20:44
might be today's date or something and
20:48
that thing is an orc expression the
20:52
effects of this orc expression is to
20:55
call the side CNM with this parameter
20:57
wait for its response and when it gets
21:01
the respond published add value
21:04
so it looks like any other thing that
21:06
you know nothing big has happened it's
21:09
just an ordinary share but then once you
21:12
have expressions you can vary longer
21:15
expressions by combining them you can
21:18
combine two or expressions in three
21:21
different ways for their free
21:22
Combinator's and each of these
21:24
combinators does something different to
21:29
do two expressions F and G in parallel
21:31
is written in this style to put a bar
21:35
between them and f ng I will go with
21:39
this detail because that's all there is
21:42
to it and then we have shoe other ways
21:47
of combining them this is this says that
21:50
for all X from app Bujji and this is
21:53
called sequential compositions and the
21:56
next one is for some X from G to ask
21:59
this position in an opposite way and
22:01
that asymmetric competition so what I'm
22:04
going to do is to go quickly over the
22:07
semantics of these in an informal
22:09
fashion and I will show you a number of
22:12
things that you can do with this so my
22:15
hope is in this one-hour lecture to be
22:17
able to convince you there there is
22:19
something here that we can use to build
22:21
large programs for the first in one hour
22:25
lecture I can't really come in sir so I
22:27
can give you some plausible arguments
22:30
so let's try with symmetric composition
22:34
as I said you expect to do F and G or
22:39
you evaluate F and G in parallel and the
22:44
idea is you do them independently and so
22:47
f will run independently it will call
22:49
some services G will call from services
22:52
and they will publish some values so
22:54
whatever values they publish publish all
22:57
the values from both as soon as they
22:58
occur and the important thing is there
23:02
is no direct communication between F&G
23:04
some of you who may know other process
23:08
algebra like CCF and CSP and I calculus
23:12
they have communications they have
23:14
synchronization there's none here let's
23:17
cure independent computation so for
23:22
instance if we wrote this Shannon Lee
23:26
Barbie BCB its effect would be to call
23:29
both CNN BBC simultaneously and as soon
23:34
as it receives a value from either of
23:37
them it will publish it so it may
23:39
publish any number of values from 0 to 2
23:42
which is CNN may not respond BBC may not
23:45
respond if both respond we get both
23:47
values by the way I teach a class an
23:52
undergraduate class at eight thirty in
23:54
the afternoon so most of them are asleep
23:57
about 20 minutes and once I tell them I
24:01
give them a rousing story idealism and
24:03
everything how about making an effort
24:05
today today a just once but no one will
24:08
sleep I have really prepared this
24:10
lecture and within 10 minutes about
24:13
twenty percent the recipe the point is
24:15
that one way i have found to keep people
24:20
from sleeping is asking questions
24:23
the other is that I encourage you to ask
24:26
me questions that fish your neighborhood
24:29
at least in a non sleeping mode so
24:31
please feel free to ask questions this
24:37
is clear that you can publish something
24:40
between 0 & 2 values so my expectation
24:44
for services of sites are quite low I
24:46
don't expect that they will return a
24:48
value or I don't write my program
24:51
assuming such a guarantee they may or
24:54
may not one thing though is that each
24:57
service will respond at most once if I
25:02
call I expect at most one response I
25:04
don't expect a stream of responses
25:06
that's one that's one property I expect
25:09
or service if you want a stream you can
25:12
program it video do some extra work now
25:16
here is sequential composition and the
25:19
idea here as I said for all values from
25:25
app do G what that means is if I wrote
25:30
no stop kemal you a ting F and whenever
25:37
it publishes a value bind that wet and
25:40
starch in new instance of G executing
25:43
with that that's idea so actually this
25:47
is a much better thing to so here is
25:51
three on the red line is an execution of
25:54
app and these are the points where f is
25:57
publishing a value and each time it
25:59
publishes a value we bind that 2x and
26:02
start a new copy of the the g0 g1 g2 so
26:07
at this moment we have three copies of G
26:09
running concurrently along with M so
26:14
this is a generalization of what you see
26:16
in because i use a primitive growing
26:22
system and I could as an ex fig
26:30
xfig was done by a colleague of mine I
26:32
learnt it onto or dizzy to change also
26:37
has that novelty of what could he have
26:39
possibly meant here yeah so that's what
26:42
FX g is well what does it mean when I
26:46
take this expression this is a really
26:50
simple one it called CNN and when it
26:54
receives a response from that it was it
26:57
binds that value to act and it calls
26:59
disservice this is email service let's
27:02
assume that email sends a mail to this
27:05
particular address which is available
27:07
everywhere and with that argument so
27:12
these are the steps that will happen all
27:15
cheer and bind resolve call email and
27:17
the value published by this expression
27:20
is the value published by the last part
27:23
any value published by CNN is consumed
27:27
internally with this X so this is pretty
27:31
similar to what you would do in a normal
27:32
Java program you will put a semicolon to
27:35
say this is the first part that's the
27:36
second one but what's different is when
27:38
you go to this example here we have this
27:43
is the first part in this the second
27:45
part here will call CNN and BBC
27:47
simultaneously and we may possibly
27:51
receive two responses one from CNN one
27:53
from BBC and with each response will
27:56
call him email so we may call email
27:59
twice up to twice and it will publish up
28:03
to two values from email whatever email
28:06
does that's interesting because it will
28:10
start up a tree of computations we can
28:14
do it if I get a chance I think I have
28:17
that example I'll show you a very nice
28:19
example of a problem that has been
28:21
solved by many people and I'll do it by
28:23
the question which I'm sure others are
28:26
also thinking of so the day with the
28:28
sequential composition you only produce
28:30
one answer but to the others you're
28:32
assuming is a stream of answers with
28:35
sequential computational you're the
28:39
biggest page you would only a sensory
28:41
symmetric composition you
28:43
we produce one answer out of F no no no
28:46
you forget publish all values from work
28:50
so this one ok just this is justice that
28:52
pretty for example ok I'm sorry I
28:54
misread it yeah this compromise up to
28:56
two values and in fact that's the reason
29:00
we are seeing this problem yeah okay
29:05
so-so yes
29:20
um
29:25
the side pole ends when the site
29:30
response they call of course ends as
29:34
soon as you call it and you don't know
29:36
if the site is ever going to respond but
29:39
once it responds and you receive the
29:41
response you know that it's finished yes
29:43
if the site has not responded you have
29:47
to keep on waiting because it may
29:49
respond sometime in the future
30:00
yeah then the in the example we never
30:03
know when f is finished we keep on
30:06
waiting for it if we know the structure
30:08
of F in like HT n n bar BBC will know
30:11
that after two answers we finish but in
30:14
general if we don't know the structure
30:15
of f while a program always know the
30:18
structure of her but if there is
30:20
recursion or some systems involved you
30:22
do not know if you have a finished I'm
30:29
going to use a bit of notation but i
30:32
hope this notation is so simple and
30:34
small that you won't bother with it too
30:36
much i'm going to take out the sex if
30:38
I'd have no relevance if for instance I
30:41
never use this xmg and i will just write
30:44
it like this and also i'm going to have
30:47
the sequential composition have
30:50
precedence over bar so i will write it
30:54
this way to denote this particular
30:57
expression which is / emphasized and
30:59
further this is going to be associated
31:04
so i will write it without parentheses
31:07
to mean just
31:12
asymmetric composition seems to be a new
31:15
idea i haven't seen this anywhere in
31:17
fact I had a long talk with Robin Milner
31:20
two weeks ago she used to I didn't read
31:23
by this I don't think he has bought it
31:25
but I believe this is an important idea
31:27
this is what I've shown you so far if
31:31
you think in terms of heads of
31:32
computations have shown you how to
31:34
create more and more threads okay I
31:37
should bar and I create a tooth bed then
31:40
I put a FX g and every time you start
31:43
something you create a new fad so this
31:45
is the way of creating new types more
31:47
and more it's being created today after
31:50
some way of killing threads and this
31:53
apply this shows how to kill it the idea
31:57
here is it's almost like the other case
32:00
you for some value published by this
32:04
side G you push that value into air and
32:08
you want to do it for some value just
32:10
one then not all values and we're going
32:13
to take the first value the first value
32:15
that G produces we want to do f with
32:17
that but there are some subtle
32:19
differences then just them from what I
32:23
just told you I would like you to start
32:27
with this example here is gee I don't
32:31
know what it is but here is the f side
32:33
left side and what i can do is start
32:40
executing f even though i don't have the
32:42
value of that quite how can i do that
32:47
well here i can call em I don't need the
32:51
value of x with that but then I would
32:54
like to do this too I can because I need
32:56
the value of x so it is suspended they
32:59
are waiting at the same time will start
33:01
running g 0 as soon as jeep publishes a
33:06
value FG never publishes value we will
33:09
just wait on that left side and effects
33:12
because we don't have the value of fact
33:13
g will keep on running but suppose G
33:17
publicist a value will bind that value
33:19
to X and now we can use this in a flash
33:22
we can call them
33:25
additionally once we have a value from G
33:28
we don't need G anymore we need this one
33:31
value which kills you and what does kill
33:35
me we will do nothing that happens with
33:39
mg we will not call services from g will
33:43
not look at any values what about some
33:46
computation that I may have started
33:48
which is halfway suppose G called two
33:50
different services it received a value
33:53
from one service and it's waiting for
33:55
the other and it produced that bad we
33:58
are happy with that value and we want to
34:00
terminate you but what happened to all
34:02
the requests that i have sent to the
34:03
other service well we can't unrequested
34:06
when the answer comes to that request
34:09
will ignore it totally so as before this
34:17
is what we do evaluate F and G in
34:19
parallel when she returns a value assign
34:21
it wax comb energy and resume suspended
34:24
calls and the values of this expression
34:27
are the values published by F the value
34:30
published by G is consumed internally so
34:34
this is the manual this way manual we
34:37
finished and well they almost finished
34:40
there is just one more concept but ok
34:46
what what happens here
34:50
as I said we would evaluate this right
34:53
side and this left side simultaneous
34:56
we'll start them out yes microphone
35:08
not sure if I am actually asking you the
35:10
question well in advance but what kind
35:14
of assumption do you make about the
35:15
structure of solution returned by one of
35:18
your function calls like when you say CN
35:21
n of T so what is the assumption you
35:24
make about the type of the format of the
35:28
output good question I make no
35:31
assumption as I told you the easiest
35:34
thing is not to make any example if you
35:36
don't process the data right if all you
35:41
do is send the data to some other
35:42
service then you don't have to process
35:45
the data the I will in my example if i
35:49
will show you some structure that i am
35:51
expecting together list but i am
35:53
expecting you a tuple but beyond that I
35:56
make no madam and I will tell you why
35:58
because it cuts down on the amount of
36:00
implementation work you have to do if
36:02
you want to if you expecting to receive
36:04
an integer and it doesn't send you an
36:06
integer you have no control you don't
36:09
know you send it to some other service
36:10
which will not like it and give you an
36:12
error message h but in the practical
36:15
implementation of the language the
36:18
students have actually put in some types
36:20
she doesn't need it to do some trivial
36:24
things otherwise which will become very
36:26
long but in the pure or language there
36:28
is no assumption about this about the
36:30
type of job you because shop when you
36:34
show this example where you pass the
36:36
value to say email which means you're
36:39
the output could be possibly relational
36:41
or something from which you pick up X
36:44
and give it to email no it's not
36:46
relational but what you are asking is
36:48
whether it would be a tuple and I take
36:50
one component or a tuple yes so there is
36:53
some structure that I will assume here
36:54
like to poof and lists are available
36:57
which is implemented but you know in
37:00
general I will not make any assumptions
37:02
about whether i am receiving Fernstrom
37:05
say we will it a large system in which
37:07
the data data was XML and all didn't do
37:13
any work with that all we did whenever
37:15
we want to pass it to send it
37:17
the service and say give me that part of
37:20
the XML thing so if you start doing data
37:24
it becomes a very it's a huge language
37:26
it types so let's look at this this
37:29
example the left side and the right side
37:33
are evaluated right away to do the left
37:37
side we get sucked right away because we
37:40
don't have the value of it to it
37:41
suspended we're waiting but we can do
37:44
something with the right side we
37:45
evaluate the right side means we start
37:47
this and this CNN and BBC simultaneous
37:51
we call them let's say that CNN responds
37:55
first as well as it responds we bind
38:00
that value to X and we can now resume
38:04
this particular expression evaluation so
38:07
we call EML the email with the value of
38:09
x at the same time we terminate this
38:12
side which means we are not going to we
38:15
are going to ignore any response that we
38:17
receive from BBC for this program will
38:21
send at most one email unlike the
38:27
previous one we might send up to you so
38:30
whichever happens first we'll do it so
38:34
all I required from the rest of the
38:36
world is that you provide me with two or
38:40
three services one is this service if
38:43
and when the input to that is a boolean
38:47
B and it returns something called a
38:51
signal if B is true and it remains
38:54
silent a beautiful what it means a
38:56
signal is a unitary date piece of data
38:59
it has no value in it it just comes
39:02
violent means it never responds so if
39:05
you call the if site and give it true
39:08
then you will immediately get a signal
39:10
if you followed it false you will never
39:12
receive it
39:14
so if is incredulous I'd start to the
39:19
side which never responds to the same as
39:23
if false very useful by the way you know
39:26
that one I mean I intended to put that
39:30
in because it sort of works like zero of
39:32
an algebra sheesh used practically all
39:35
the time by writing large programs you
39:37
want to cut out feds desktop tip now
39:41
just returns a signal it's same as if
39:43
true and the last one is where is quite
39:48
important I call it our timer arts
39:51
transfer relative which takes an integer
39:53
as input positive integer non-negative
39:56
integer as input and it returns a signal
40:00
exactly a time units later but right now
40:03
our time units in our implementation of
40:05
milliseconds so if I rode our time were
40:08
20 then exactly 20 milliseconds later a
40:11
loosey goosey there is no notion of time
40:16
built into all except through this and
40:18
that is it and we'll be able to do a few
40:22
things with this to imagine that an
40:26
expression is evaluated and single
40:28
machine that I'll poke line that client
40:30
communicates with the sides by sending
40:32
messages to them and all fundamental
40:34
sites are local to the client all except
40:37
our timer as phone immediately and I
40:41
won't explain the last part this is the
40:45
model the programmer should keep in mind
40:47
it's not the true model because if you
40:50
write a large program you can have a
40:52
centralized execution it'll be
40:54
distributed but the programmer shouldn't
40:56
worry about it will take care of
40:57
distribution will make sure that when we
41:00
distribute we support the same semantics
41:02
as a centralized model so that's
41:06
affection we don't ask people to say
41:08
this is a process and that's the process
41:09
and that can go on this computer I think
41:12
in reality it's very difficult to manage
41:14
that so we'll keep a simple model and
41:17
manage to do everything automatically
41:22
last part of the language is definition
41:25
facility so here is a little program
41:27
which you have seen before it tends to
41:32
an address a at most one email so I am
41:37
giving it a name i'll call this mail
41:39
once and that's just expression HRM
41:44
today mmm is a bound variable in this
41:46
expression that's a pricey as soon as
41:50
you have this facility you can see that
41:52
you can put the left side name on the
41:54
right side and you can get recursion and
41:57
that's the only way you can get
41:59
unbounded computation what I've shown
42:01
you so far will not give you unbonded
42:03
competition it is bounded and the
42:05
unbounded computation here male loop ad
42:09
just imagine d is an interval like a day
42:13
and here i start out by calling mail
42:16
once a which will send at most one email
42:20
today and then it waits for b units of
42:24
time maybe a day and then it goes back
42:26
and we does this program very
42:29
effectively every morning it falls the
42:33
true news sites that's one response from
42:36
them and emails that and if you from
42:39
doing it forever
42:42
so that is the conclusion of the model
42:44
it's taking a little longer than I had
42:46
expected but it's more important that
42:47
you understand it are there any
42:49
questions before I show you some
42:51
examples yes I'm just curious how you
42:59
decided between three particular
43:02
combinatorial facilities you have where
43:04
the right three or the only three you
43:06
needed yes very important question in
43:09
doing any research the short answer I
43:12
don't know if these are the correct ones
43:14
just like in any process algebra you can
43:18
come up with a number of combinations
43:19
and the only way you can sort of justify
43:24
them is by empirical investigations you
43:27
try a number of benchmark examples you
43:29
see how you're doing you have some
43:32
theoretical ideas like yes this
43:34
Combinator's a nice properties like
43:35
they're monotonic and continuous those
43:37
are nice copy you will try what other
43:40
people have done and show that you can
43:42
simulate their Combinator's that show
43:45
that well maybe it's as powerful as I
43:46
calculus or ccsf I mean that's one thing
43:49
but what I can't prove to you that I
43:52
have got it in exactly the right form
43:54
maybe these two Combinator's overlap
43:56
somewhat and I could have created
43:58
something better I don't know that I
43:59
suspect they don't overlap too much if
44:03
they do but no I don't have a
44:06
theoretical answer to your question
44:20
what about the error handling mechanisms
44:23
for example if I can't constrain if
44:24
there is more than 10 gigabyte data just
44:27
ignore it yeah that's the that's the
44:37
really important problem that unless you
44:40
can handle error what are you doing
44:42
internet is a computer if everything
44:44
worked perfectly we won't need any of
44:46
these problems we can write in Java just
44:48
tell this this data is available there
44:50
and that piece of data and some of the
44:52
examples I will show next though clearly
44:55
answers all the questions here is a
44:58
little example i am defining something
45:01
called metronome metronome publishes a
45:05
signal every time unit how does it do
45:08
that well it starts by publishing a
45:11
signal it waits for one unit and then it
45:15
calls metronome so how do I say this how
45:21
do I say this on the one side i have
45:24
this which will publish a signal
45:25
immediately on the right side i have an
45:27
expression that waits for one unit and
45:30
then behave so like metronome and if you
45:34
want to look at it a little more
45:36
carefully we are starting to threads S
45:39
stands for signal and our for this right
45:41
side expression so we do these two
45:44
things independently and this will
45:50
publish a signal and then the right side
45:52
is our and this entire tree the same
45:55
tree so this does a signal and it waits
45:58
for one unit so this goes on forever
46:00
publishing a signal where is that
46:05
interesting let me take up a little
46:08
problem suppose I have an expression i
46:12
will call this gen I it publishes these
46:18
values starting from I I I plus 1 etc at
46:22
unit intervals suppose I i can write
46:24
such an expression it will be like
46:26
metronome so gen 3 will publish first
46:29
three right away then
46:31
for one in it later 52 years later and
46:34
go on forever suppose I have a site
46:38
prime n which returns n if n is prime
46:42
and it doesn't do anything it doesn't
46:44
respond at all if n is not trying to
46:48
write a program to publish all prime
46:50
numbers and here is the program but what
46:57
I would like you to know is that there
46:59
is no explicit loop here there is no
47:02
explicit recursion here either I'm not
47:06
showing it to you there is no recursion
47:08
it's straightforward it goes from left
47:09
to right what's happening is the
47:12
structure of sequential composition
47:13
every time it publishes a value it will
47:16
start up a new execution of this so the
47:21
recursion is hidden inside this gen to
47:23
its producing a stream and for each
47:25
value of the stream we are taking up and
47:27
doing something and this cat iodine
47:29
which we found to be quite useful it
47:31
simplifies programming you don't have to
47:33
explicitly show a loop for a recursion
47:35
or something anytime you want to do
47:37
something unbounded time out here is one
47:42
answer for your question that i would
47:44
like to call the site m and publish its
47:48
response if it arrives before time T
47:50
otherwise I want to publish 0 so what
47:54
I'll do is take this expression on the
47:57
right side what does it do it called Sam
47:59
at the same time it calls our trimurti
48:03
the pools i get a value from em before
48:06
teatime units that that value will be
48:09
published that will be the first value
48:11
it will be bound to Z and I will
48:13
publicity but suppose I wait for tea
48:16
time units m doesn't respond and this is
48:19
going to publish as 0 that will be the
48:22
first value published that will be bound
48:23
to Z and that's what I'll publish in the
48:26
meantime if any value is published here
48:29
the rest of the expression execution is
48:32
terminated
48:36
okay we can leverage this we can use
48:39
this to get all kinds of different time
48:42
out go on maybe maybe some of the other
48:47
examples will show how we can do this
48:50
this is their paradigm that's much loved
48:53
by people in concurrent programming for
48:55
join parallelism you want to call we had
48:58
two services in parallel and proceed
49:01
only after both of them respond we don't
49:03
have that there is no such Combinator
49:05
that is what we can do we can output a
49:09
tuple U and V where you is from m and v
49:13
is from n remember that this thing in
49:18
black is one expression and this
49:21
expression has v followed by an how do
49:24
you evaluate this expression you start
49:26
evaluating the left side and you call em
49:29
as soon as n is bound as soon as n
49:32
produces a value that will be bound to
49:33
be oh good how do you evaluate this
49:37
expression the internal expression now
49:40
you start evaluating this and also call
49:43
em at the same time you can't do
49:46
anything with this because they are all
49:47
unbound so effectively you called M&M at
49:51
the same time waiting to receive their
49:54
responses and only when you get both of
49:57
them because otherwise this can't be
49:58
evaluated only when you get both of them
50:01
you are put them so this structure
50:04
occurs so often that i'm going to just
50:08
write it this way without any
50:10
parenthesis it's left associated or
50:12
fight often i write it this way because
50:14
it's easier to read and we get folk join
50:19
you can do barrier synchronization the
50:21
same way but let me show you a harder
50:24
problem there's a practical problem i
50:29
have a list of students that I teach and
50:33
if they've done very well I invite the
50:37
top three or four students to join my
50:39
research group at one time they would
50:41
jump up nowadays you don't hear from
50:42
them so this program will send a email
50:50
pull them both inside a number of sites
50:53
and it counts how many responses you
50:56
receive within a certain time period
50:58
just account I will call that count ally
51:02
and the input to this program is a list
51:05
of sites to call all the sites and that
51:10
list simultaneously wait for 10 time
51:14
units and then publish an answer how
51:17
many responded in 10 time units now we
51:23
write it in this way this style is very
51:26
similar to functional programming if
51:28
your list is empty your answer is going
51:30
to be 0 because you aren't going to call
51:33
anyone no response is received if your
51:35
input is of this form the first entry is
51:39
M and they're less to the list is ms but
51:42
I would like to do the store in you this
51:45
quantity this quantity is going to be
51:48
one the result the integer one if M
51:53
response within 10 time units it will be
51:56
0 if M does not respond within 10
52:00
veneers and you can see the structure
52:02
that we run these two computations
52:05
simultaneously which ever published
52:07
first goes into you at the same time
52:11
they run tally on the rest of the list
52:14
in parallel and store the result in V
52:18
and the answer you wanted u plus V the
52:26
point I want to make here is self you
52:28
might be familiar with functional
52:30
programming and you see a great deal of
52:31
similarity here with functional
52:33
programming realize that this is not
52:35
functional at all there is a great deal
52:38
of non-determinism here which one there
52:41
is a time were involved here there is a
52:44
abortion of computation at some point
52:47
halfway through some competition was
52:49
terminating in fact whole bunch of these
52:52
computations are terminated recursively
52:54
and yet we can reason about it in a
52:57
fairly functional style way and that I
53:00
felt was sort of important when I wrote
53:02
this
53:03
maybe we have something going here let
53:07
me skip this barrier synchronization
53:08
that's quite easy priority let's just do
53:15
this I want to call a side n and I would
53:21
like to receive its response but I don't
53:26
want to receive it quickly strange thing
53:28
why wouldn't you want to receive it
53:29
friction now I don't want to receive it
53:31
quickly just hold up so I want to call
53:35
an airline and now I'm going to go get a
53:37
coffee cup of coffee and I will back in
53:39
10 minutes and I don't want to receive
53:41
that response for 10 minutes so these
53:45
are the new paradigms for internet kind
53:47
of computing you don't see them in
53:49
operating systems or anything so how do
53:52
you go about this this strange but let
53:57
me suggest that one way to think of it
53:59
is that they were running two threads of
54:01
computation you are calling the airline
54:02
that's one thread of computation and you
54:05
are calling a timer with 10 minutes
54:07
that's another thread of computation and
54:08
you want to do a fork join on them and
54:11
that's what i'm doing here so i will run
54:16
this on one thread i will have our timer
54:19
1 followed by out would you and the you
54:22
is going to come from n we understand
54:26
this by first evaluating this expression
54:28
this expression and this simultaneously
54:31
so we are going to call n right away and
54:33
we're going to call our time or one
54:35
right away now suppose this response
54:40
first n has been cloudy then we'll come
54:43
here but we can't output this you will
54:45
be waiting and when n response that's
54:48
fine so we waited at least one unit but
54:51
suppose n response right away you're
54:53
still waiting for this one to finish and
54:55
only then will output you so this delays
55:00
artificially by some amount a response
55:02
that we could receive what is its effect
55:04
well I want to solve this problem where
55:08
I call m and n together if mm is my
55:12
favorite site let's say m and n are
55:14
Airlines american and delta let's say
55:16
I like American which is not true but
55:19
let's assume that for the moment and I
55:22
want to give him a little extra American
55:24
so I'm going to wait for 10 minutes
55:26
within 10 minutes if American response
55:28
I'll take its response irrespective of
55:31
when Delta responded before or after but
55:34
I have a limited patience after 10
55:36
minutes if American has not responded
55:38
then whoever responded who has this
55:41
favor responsibility and as you can see
55:45
that's very easily done just run em and
55:47
Randall a simultaneously this delay and
55:53
publish whichever comes first
56:01
ah there's a clock
56:10
three minutes three minutes good okay
56:15
interrupt can be done parallel or this
56:21
is an important one this was actually a
56:23
very important one I mean in in my own
56:25
research I wrote down several semantics
56:28
of the day synchronous composition and I
56:31
had to use a particular semantics we
56:33
have the site and I think it's the right
56:34
one parallel or is comes up in a number
56:37
of contacts you may have heard of it
56:39
before the problem is this suppose you
56:41
have two sites which respond with
56:44
boolean when you call them the may or
56:46
may not respond but when they do they
56:47
respond with true or false if you get
56:50
and you were supposed to take the
56:52
logical or of the two values of you
56:53
there but if you see a true from one of
56:57
the site you can publish that right away
56:59
without saying rather and that's quite
57:02
difficult you can do it in functional
57:04
programming because you have to choose
57:06
one or the other we can do it here
57:09
because it's all symmetric this is the
57:12
way we'll do it we'll call em n n the
57:15
sites that are supposed to return
57:16
boolean and this is the main expression
57:19
that's running if X is if X is true then
57:25
publish it true if Y is true then
57:26
publish the truth otherwise take their
57:29
logical or or is a site just logical or
57:32
and publish their to see that if suppose
57:36
M response to the true then immediately
57:38
this branch will publish it true suppose
57:43
that X Des Moines respond to the false
57:46
and this is silent it won't publish
57:48
anything but maybe y will come through
57:51
and it's true and then this is going to
57:53
publish but then this is also going to
57:56
publish because or of XY is now can be
57:59
computed 30 published today I'll say
58:02
that will publish the first true as soon
58:04
as it comes you also see that you also
58:07
might publish a whole bunch of other
58:08
things like if they're both true what
58:10
will happen will publish three things
58:13
right the first time for this design we
58:16
don't want that we want just one value
58:18
how do we get one value yeah we know how
58:22
to put out everything else by doing this
58:24
right well let's see and publicity that
58:27
publishes one value that's it so they
58:32
are lot more I could show you but I
58:33
don't have time so let me finish with
58:36
where i started the airlines example but
58:39
I said as soon as I find a value below
58:42
three hundred dollars by the ticket that
58:44
is parallel or it says that as soon as
58:48
you see something that meets the
58:49
criterion act upon it and unless you
58:52
have the solution you can't solve the
58:54
problem so with this it works for
58:56
clothes trivially i'll be i will not be
59:01
here tomorrow but i will be a Duke and
59:03
UNC so you're welcome to come there and
59:06
talk to me or you're welcome to send me
59:08
email there is a waves website which is
59:10
quite nice and they have shown it to you
59:20
where I encourage you to go here and
59:29
this is mostly done by my students and
59:32
they promised to teach orc in 15 minutes
59:33
so you don't need a whole hour thank you
59:36
so much I think this is your site's
59:46
other sites connecting and they may be
59:48
disconnecting will give them the first
59:50
priority and ask me any questions other
59:59
color questions from remote sites
60:09
this is exactly what happens in all you
60:11
send out a request and you are just
60:13
waiting all right maybe they can hear
60:17
you but you know simple questions if
60:21
would be remote site I like to ask any
60:23
question yeah I have one question my
60:27
name is Lakshmi Narasimha Hannah I'm
60:29
calling I'm talking from East Carolina
60:32
University at the Greenville how does
60:39
these semantics in our go with say for
60:41
example WS eventing in a web services
60:45
eventing yes let me repeat the question
60:52
so how can i exploit services I don't
60:59
want the user what service how can i
61:01
exploit the construct like visto so is
61:07
that the kind of question you wanted to
61:09
ask um you have some more similar to
61:14
that now there's a specific I don't know
61:16
emily is he I know it's very painful let
61:18
me tell you what I call him oh I
61:20
expected that rest of the world will
61:22
develop some standards by which services
61:25
can talk to each other that's the next
61:27
logical thing to do I felt five-year
61:29
saga and there was some standard called
61:31
W wisco wsdl soap and they were unusable
61:36
but then I felt that some new standard
61:38
will emerge and this is one AAA we have
61:41
infused with disappointed it is wasting
61:44
a lot of behind because every web
61:46
service provides the different interface
61:48
it doesn't work very well whistle is
61:50
extremely hard it wastes a lot of time
61:52
recently they have come up with a
61:54
standard for the rest resd it seems to
61:57
be slightly better that's what my
61:59
students tell me but it's really
62:01
impaired are you certain by now we
62:03
expect it hundreds of sites that they
62:05
can talk to the only set of sites which
62:08
were reasonably happy are the google
62:09
sites they seem to be reasonable in
62:12
publishing their api so that we can talk
62:14
to them google spell checker we use
62:16
google search we use google calendar
62:18
will use in fact one of the demos at
62:21
I couldn't show was to go look for all
62:27
kinds of bands that are playing in
62:30
Austin over the weekend and put their
62:32
name into your Google Calendar and send
62:35
emails through your friend when a
62:37
particular band is playing asking them
62:39
do you want me to buy a ticket for their
62:41
band respond in 30 minutes very short
62:44
program about five or six lines but this
62:46
is the kind of thing we would like to do
62:48
with many other sites and I have not
62:49
been able to it because the standards
62:51
aren't there and this is we are not in
62:53
the standard business we wanted to use
62:54
standard protocol prophecy well I put we
62:59
answered a tangential question but
63:02
something has been answered okay all
63:07
right right okay local site any
63:10
questions thank you must have answered
63:16
all the questions during my talk thank
63:18
you there is a question here yes so I
63:21
was wondering so you're you're depending
63:23
on a stint in a fairly strong
63:26
standardization in terms of what a sight
63:28
will return and what a sight will accept
63:31
at some point right so because as of now
63:33
on I will not put it will return but its
63:35
signature it needs three parameters one
63:39
of the parameters has to be integer one
63:41
has to be a date one has to be a string
63:42
and will return something I don't care
63:45
much what that something but I want to
63:47
know how to call that site and how many
63:50
parameters it takes and what they should
63:51
be like but but logically or even if the
63:56
parameters remain the same logically so
63:58
at this time we find for example in our
64:01
site which used to return I'm just
64:03
talking about websites and human
64:04
operation it used to return plaintext it
64:07
returns the same information now but
64:09
embedded in a huge XML document with
64:11
nice flowery borders and so on so is so
64:15
until there is a very strong
64:16
standardization there does doesn't it
64:19
sort of you know move the burden from
64:22
the programmer to the programmer of the
64:25
compiler if you will the whoever has to
64:27
you know your students that have to
64:29
maintain arc as it were yeah this is a
64:32
real problem so so roughly speaking
64:34
you're asking
64:35
suppose yesterday the arithmetic unit
64:38
addition unit was adding but now today
64:40
it's multiplying so how do you maintain
64:42
your program yeah that's the real
64:45
problem and you do I get all kinds of
64:49
errors actually they don't send HTML
64:53
documents that much it's XML is the
64:55
standard now and we are more hopeful
64:57
because XML is at least in some sense
65:00
have some kind of a grammar somewhere
65:02
some website so you can do slightly
65:04
better but no I'm I agree with you it's
65:07
a true very hard problem so if you want
65:10
to build a internet computer there
65:12
should be some places where services are
65:14
going to be standardized maybe a
65:16
location is not standardized I call that
65:18
location it might redirect me to another
65:21
location webservice aveiro that's fine I
65:23
don't see that that becomes transparent
65:25
it just wastes a lot of time but that's
65:27
fine but if it changes its interface
65:31
it's very difficult manage whoo it's
65:37
about um I was going to ask what do you
65:39
think are the network traffic
65:42
implications of this I mean we've
65:43
already seen that things like
65:46
peer-to-peer traffic are consuming or at
65:48
least people certain people are afraid
65:50
that they're taking over the internet I
65:51
mean I don't think that's true but
65:52
that's a problem if you're having to do
65:55
every well not every but a large
65:57
percentage of your calculations using
66:00
machines which are somewhere else
66:02
there's a lot of burden on the internet
66:04
wouldn't you say yeah true and the way
66:07
to treat it is to assume that that's the
66:09
infinite resource which is provided by
66:11
someone else the practical answer is
66:15
that and this is not something we have
66:18
done the practical answer is when you
66:20
see that you are using a service over
66:22
and over to automatically migrate that
66:25
service to your local computer without
66:28
the user knowing it these are
66:30
optimizations and they're important
66:32
optimizations I was talking to some
66:36
people in your department who are doing
66:37
some very interesting work on
66:38
orchestrating grid computations and they
66:41
are moving huge amounts of data from one
66:43
place to another so today terabyte does
66:48
take a lot of time
66:49
and petabytes just can't be done it's
66:52
too much and I don't know how to solve
66:54
those problems that I suspect that we'll
66:56
have migrations happening automatically
66:59
depending on traffic pattern and other
67:01
things but I won't worry too much about
67:03
whether the network is getting saturated
67:05
somebody can't watch NFL their problem
67:12
can you say a little bit about how you
67:15
would maybe distribute this across
67:16
multiple systems I mean we've talked
67:18
about a central computer here and you
67:20
made a value respond yeah you should
67:23
like to invite me back as distinguished
67:25
lecturer again because at the thought
67:27
that's a that's a falafel but let me
67:30
give you a 15-second answer I would like
67:33
to take an expression and analyze it and
67:38
figure out that certain parts of it can
67:40
be independently evaluated for instance
67:43
if I they get bad G almost always i can
67:48
have F running on one computer G on
67:50
another computer and the effect is the
67:51
same a one exception to that is f and g
67:55
are both deferring to the same clock
67:57
they referring to our timer and we can't
68:01
distribute the same clock perfectly at
68:03
all solutions but then it's not as bad
68:07
it sort of goes sometimes they're
68:09
they're both referring to the same plot
68:11
but their effect on your mask you can
68:14
figure out so there is a theory that I
68:17
have developed which is not complete but
68:20
it's almost there on how we can
68:22
distribute it there is a distributed
68:23
implementation which works in a
68:25
conservative aspect of this theory and
68:27
now we are sort of aggressively making
68:29
it distributed so instead of actually I
68:32
feel oh the user specifying that
68:33
distribute this we figure out what can
68:37
be distributed over 20 missions in fact
68:39
we are running multiple service just for
68:42
that I don't think this will work if you
68:45
have to do everything on one machine the
68:46
whole purpose of loss you want to build
68:48
process networks you must actually
68:52
distribute them well no I time it is
68:55
used as you well know if there is
68:57
completely essington even this F and G
69:00
goes into thing
69:01
fxj f'kin one machine vm another machine
69:04
similarly for the other one so it
69:06
completely is there a distinction
69:14
between local sites such as if versus
69:18
remote sites I guess email CNN their
69:21
remote sites you said something yes I'm
69:24
embarrassed to admit there is a
69:26
distinction I don't quite understand it
69:29
we use it all the time roughly speaking
69:31
local sites are supposed to respond to
69:34
me lately they never fail and they're
69:37
supposed to respond immediate from there
69:40
and when they should respond well if
69:43
Paul's will not respond if true should
69:46
respond immediately there is a notion of
69:47
time there is an hour timer and and we
69:52
do it do it this fact but where the
69:56
semantics of this well no actually we
69:58
have this mantic but it's not something
70:00
very easy to explain right away I wish I
70:03
could but I don't have the declination
70:11
that's a lot of questions so I think
70:13
I've kept you all awake thank you again