WEBVTT
Kind: captions
Language: en

00:00:04.840 --> 00:00:07.770 align:start position:0%
 
hi<00:00:05.170><c> everyone</c><00:00:05.440><c> good</c><00:00:06.130><c> morning</c><00:00:06.490><c> my</c><00:00:07.300><c> name</c><00:00:07.450><c> is</c><00:00:07.480><c> Sean</c>

00:00:07.770 --> 00:00:07.780 align:start position:0%
hi everyone good morning my name is Sean
 

00:00:07.780 --> 00:00:09.629 align:start position:0%
hi everyone good morning my name is Sean
and<00:00:07.810><c> I'm</c><00:00:08.140><c> working</c><00:00:08.320><c> on</c><00:00:08.560><c> the</c><00:00:08.620><c> formality</c><00:00:09.430><c> proof</c>

00:00:09.629 --> 00:00:09.639 align:start position:0%
and I'm working on the formality proof
 

00:00:09.639 --> 00:00:12.320 align:start position:0%
and I'm working on the formality proof
language<00:00:10.030><c> with</c><00:00:10.690><c> my</c><00:00:10.809><c> co-founder</c><00:00:10.990><c> Victor</c><00:00:11.559><c> Maya</c>

00:00:12.320 --> 00:00:12.330 align:start position:0%
language with my co-founder Victor Maya
 

00:00:12.330 --> 00:00:15.539 align:start position:0%
language with my co-founder Victor Maya
what's<00:00:13.330><c> a</c><00:00:13.389><c> proof</c><00:00:13.570><c> language</c><00:00:14.250><c> so</c><00:00:15.250><c> let's</c><00:00:15.400><c> do</c><00:00:15.520><c> a</c>

00:00:15.539 --> 00:00:15.549 align:start position:0%
what's a proof language so let's do a
 

00:00:15.549 --> 00:00:18.870 align:start position:0%
what's a proof language so let's do a
quick<00:00:15.760><c> refresher</c><00:00:16.090><c> on</c><00:00:16.209><c> type</c><00:00:16.539><c> systems</c><00:00:17.880><c> here's</c>

00:00:18.870 --> 00:00:18.880 align:start position:0%
quick refresher on type systems here's
 

00:00:18.880 --> 00:00:20.310 align:start position:0%
quick refresher on type systems here's
some<00:00:19.030><c> pseudocode</c><00:00:19.300><c> representing</c><00:00:19.990><c> an</c><00:00:20.080><c> array</c>

00:00:20.310 --> 00:00:20.320 align:start position:0%
some pseudocode representing an array
 

00:00:20.320 --> 00:00:22.620 align:start position:0%
some pseudocode representing an array
indexing<00:00:20.950><c> function</c><00:00:21.130><c> in</c><00:00:21.610><c> an</c><00:00:21.790><c> untyped</c><00:00:22.180><c> language</c>

00:00:22.620 --> 00:00:22.630 align:start position:0%
indexing function in an untyped language
 

00:00:22.630 --> 00:00:25.500 align:start position:0%
indexing function in an untyped language
I<00:00:22.870><c> take</c><00:00:23.500><c> an</c><00:00:23.590><c> index</c><00:00:23.980><c> and</c><00:00:24.190><c> an</c><00:00:24.550><c> array</c><00:00:24.820><c> and</c><00:00:25.120><c> I</c><00:00:25.270><c> try</c>

00:00:25.500 --> 00:00:25.510 align:start position:0%
I take an index and an array and I try
 

00:00:25.510 --> 00:00:27.090 align:start position:0%
I take an index and an array and I try
to<00:00:25.540><c> get</c><00:00:25.780><c> whatever's</c><00:00:26.140><c> inside</c><00:00:26.320><c> the</c><00:00:26.590><c> array</c><00:00:26.830><c> at</c>

00:00:27.090 --> 00:00:27.100 align:start position:0%
to get whatever's inside the array at
 

00:00:27.100 --> 00:00:30.990 align:start position:0%
to get whatever's inside the array at
that<00:00:27.340><c> index</c><00:00:28.110><c> get</c><00:00:29.110><c> 1</c><00:00:29.380><c> is</c><00:00:29.680><c> bar</c><00:00:30.250><c> because</c><00:00:30.760><c> array</c>

00:00:30.990 --> 00:00:31.000 align:start position:0%
that index get 1 is bar because array
 

00:00:31.000 --> 00:00:34.940 align:start position:0%
that index get 1 is bar because array
indices<00:00:31.270><c> start</c><00:00:31.690><c> at</c><00:00:31.750><c> 0</c><00:00:31.960><c> and</c><00:00:32.259><c> get</c><00:00:33.250><c> 2</c><00:00:33.460><c> is</c><00:00:33.760><c> bats</c>

00:00:34.940 --> 00:00:34.950 align:start position:0%
indices start at 0 and get 2 is bats
 

00:00:34.950 --> 00:00:36.360 align:start position:0%
indices start at 0 and get 2 is bats
here's<00:00:35.950><c> a</c><00:00:36.040><c> riddle</c>

00:00:36.360 --> 00:00:36.370 align:start position:0%
here's a riddle
 

00:00:36.370 --> 00:00:39.060 align:start position:0%
here's a riddle
if<00:00:36.489><c> get</c><00:00:36.760><c> 1</c><00:00:36.940><c> is</c><00:00:37.089><c> bar</c><00:00:37.329><c> and</c><00:00:37.600><c> get</c><00:00:37.719><c> 2</c><00:00:37.899><c> is</c><00:00:38.050><c> baz</c><00:00:38.289><c> what's</c>

00:00:39.060 --> 00:00:39.070 align:start position:0%
if get 1 is bar and get 2 is baz what's
 

00:00:39.070 --> 00:00:43.319 align:start position:0%
if get 1 is bar and get 2 is baz what's
get<00:00:39.309><c> 1.5</c><00:00:40.410><c> better</c><00:00:41.410><c> question</c><00:00:41.769><c> what</c><00:00:42.370><c> should</c><00:00:42.789><c> get</c>

00:00:43.319 --> 00:00:43.329 align:start position:0%
get 1.5 better question what should get
 

00:00:43.329 --> 00:00:47.880 align:start position:0%
get 1.5 better question what should get
1.5<00:00:43.899><c> be</c><00:00:44.109><c> a</c><00:00:45.089><c> runtime</c><00:00:46.089><c> error</c><00:00:46.620><c> indexing</c><00:00:47.620><c> an</c><00:00:47.710><c> array</c>

00:00:47.880 --> 00:00:47.890 align:start position:0%
1.5 be a runtime error indexing an array
 

00:00:47.890 --> 00:00:49.439 align:start position:0%
1.5 be a runtime error indexing an array
with<00:00:48.070><c> a</c><00:00:48.100><c> non</c><00:00:48.309><c> integer</c><00:00:48.609><c> makes</c><00:00:48.999><c> no</c><00:00:49.149><c> sense</c>

00:00:49.439 --> 00:00:49.449 align:start position:0%
with a non integer makes no sense
 

00:00:49.449 --> 00:00:51.750 align:start position:0%
with a non integer makes no sense
because<00:00:49.989><c> an</c><00:00:50.230><c> untyped</c><00:00:50.589><c> language</c><00:00:51.010><c> but</c><00:00:51.609><c> a</c><00:00:51.640><c> none</c>

00:00:51.750 --> 00:00:51.760 align:start position:0%
because an untyped language but a none
 

00:00:51.760 --> 00:00:53.279 align:start position:0%
because an untyped language but a none
type<00:00:51.909><c> language</c><00:00:52.239><c> lets</c><00:00:52.600><c> you</c><00:00:52.690><c> shoot</c><00:00:52.870><c> yourself</c><00:00:52.960><c> in</c>

00:00:53.279 --> 00:00:53.289 align:start position:0%
type language lets you shoot yourself in
 

00:00:53.289 --> 00:00:55.049 align:start position:0%
type language lets you shoot yourself in
the<00:00:53.350><c> foot</c><00:00:53.589><c> and</c><00:00:53.769><c> make</c><00:00:54.280><c> a</c><00:00:54.309><c> bad</c><00:00:54.489><c> function</c><00:00:54.879><c> call</c>

00:00:55.049 --> 00:00:55.059 align:start position:0%
the foot and make a bad function call
 

00:00:55.059 --> 00:00:58.169 align:start position:0%
the foot and make a bad function call
and<00:00:55.300><c> this</c><00:00:55.690><c> only</c><00:00:55.929><c> fails</c><00:00:56.109><c> during</c><00:00:56.319><c> execution</c><00:00:57.179><c> ie</c>

00:00:58.169 --> 00:00:58.179 align:start position:0%
and this only fails during execution ie
 

00:00:58.179 --> 00:00:59.969 align:start position:0%
and this only fails during execution ie
when<00:00:58.600><c> your</c><00:00:58.749><c> codes</c><00:00:59.019><c> running</c><00:00:59.379><c> and</c><00:00:59.559><c> can</c><00:00:59.739><c> affect</c>

00:00:59.969 --> 00:00:59.979 align:start position:0%
when your codes running and can affect
 

00:00:59.979 --> 00:01:02.700 align:start position:0%
when your codes running and can affect
the<00:01:00.069><c> world</c><00:01:00.190><c> around</c><00:01:00.460><c> it</c><00:01:01.350><c> runtime</c><00:01:02.350><c> errors</c><00:01:02.589><c> are</c>

00:01:02.700 --> 00:01:02.710 align:start position:0%
the world around it runtime errors are
 

00:01:02.710 --> 00:01:04.229 align:start position:0%
the world around it runtime errors are
tough<00:01:02.920><c> because</c><00:01:03.129><c> sometimes</c><00:01:03.609><c> they</c><00:01:03.729><c> do</c><00:01:03.789><c> nothing</c>

00:01:04.229 --> 00:01:04.239 align:start position:0%
tough because sometimes they do nothing
 

00:01:04.239 --> 00:01:05.969 align:start position:0%
tough because sometimes they do nothing
and<00:01:04.420><c> sometimes</c><00:01:05.050><c> they</c><00:01:05.350><c> cause</c><00:01:05.530><c> your</c><00:01:05.710><c> spacecraft</c>

00:01:05.969 --> 00:01:05.979 align:start position:0%
and sometimes they cause your spacecraft
 

00:01:05.979 --> 00:01:08.310 align:start position:0%
and sometimes they cause your spacecraft
to<00:01:06.430><c> perform</c><00:01:06.820><c> a</c><00:01:07.030><c> rapid</c><00:01:07.690><c> unscheduled</c>

00:01:08.310 --> 00:01:08.320 align:start position:0%
to perform a rapid unscheduled
 

00:01:08.320 --> 00:01:10.740 align:start position:0%
to perform a rapid unscheduled
disassembly<00:01:08.950><c> your</c><00:01:09.850><c> codes</c><00:01:10.030><c> runtime</c><00:01:10.360><c> could</c><00:01:10.600><c> be</c>

00:01:10.740 --> 00:01:10.750 align:start position:0%
disassembly your codes runtime could be
 

00:01:10.750 --> 00:01:12.510 align:start position:0%
disassembly your codes runtime could be
in<00:01:10.899><c> five</c><00:01:11.110><c> minutes</c><00:01:11.469><c> on</c><00:01:11.619><c> your</c><00:01:11.770><c> laptop</c><00:01:12.159><c> or</c><00:01:12.460><c> it</c>

00:01:12.510 --> 00:01:12.520 align:start position:0%
in five minutes on your laptop or it
 

00:01:12.520 --> 00:01:14.130 align:start position:0%
in five minutes on your laptop or it
could<00:01:12.610><c> be</c><00:01:12.700><c> 30</c><00:01:12.939><c> years</c><00:01:13.240><c> for</c><00:01:13.450><c> now</c><00:01:13.570><c> on</c><00:01:13.780><c> devices</c>

00:01:14.130 --> 00:01:14.140 align:start position:0%
could be 30 years for now on devices
 

00:01:14.140 --> 00:01:16.020 align:start position:0%
could be 30 years for now on devices
that<00:01:14.320><c> don't</c><00:01:14.530><c> even</c><00:01:14.770><c> exist</c><00:01:14.890><c> yet</c><00:01:15.100><c> you</c><00:01:15.759><c> don't</c><00:01:15.880><c> know</c>

00:01:16.020 --> 00:01:16.030 align:start position:0%
that don't even exist yet you don't know
 

00:01:16.030 --> 00:01:19.109 align:start position:0%
that don't even exist yet you don't know
its<00:01:16.329><c> runtime</c><00:01:17.219><c> by</c><00:01:18.219><c> adding</c><00:01:18.460><c> some</c><00:01:18.610><c> types</c><00:01:18.820><c> we</c><00:01:19.000><c> can</c>

00:01:19.109 --> 00:01:19.119 align:start position:0%
its runtime by adding some types we can
 

00:01:19.119 --> 00:01:21.389 align:start position:0%
its runtime by adding some types we can
get<00:01:19.240><c> the</c><00:01:19.329><c> compiler</c><00:01:19.780><c> to</c><00:01:19.810><c> complain</c><00:01:20.229><c> hey</c><00:01:20.680><c> fix</c>

00:01:21.389 --> 00:01:21.399 align:start position:0%
get the compiler to complain hey fix
 

00:01:21.399 --> 00:01:23.160 align:start position:0%
get the compiler to complain hey fix
your<00:01:21.579><c> code</c><00:01:21.729><c> you</c><00:01:22.329><c> can't</c><00:01:22.509><c> have</c><00:01:22.659><c> an</c><00:01:22.750><c> index</c><00:01:23.049><c> that's</c>

00:01:23.160 --> 00:01:23.170 align:start position:0%
your code you can't have an index that's
 

00:01:23.170 --> 00:01:25.889 align:start position:0%
your code you can't have an index that's
not<00:01:23.350><c> an</c><00:01:23.469><c> integer</c><00:01:23.789><c> this</c><00:01:24.789><c> error</c><00:01:25.210><c> might</c><00:01:25.719><c> look</c>

00:01:25.889 --> 00:01:25.899 align:start position:0%
not an integer this error might look
 

00:01:25.899 --> 00:01:27.630 align:start position:0%
not an integer this error might look
deceptively<00:01:26.170><c> similar</c><00:01:26.710><c> the</c><00:01:26.950><c> previous</c><00:01:27.280><c> one</c><00:01:27.460><c> but</c>

00:01:27.630 --> 00:01:27.640 align:start position:0%
deceptively similar the previous one but
 

00:01:27.640 --> 00:01:30.359 align:start position:0%
deceptively similar the previous one but
there's<00:01:27.820><c> one</c><00:01:28.060><c> crucial</c><00:01:28.689><c> difference</c><00:01:29.039><c> it</c><00:01:30.039><c> occurs</c>

00:01:30.359 --> 00:01:30.369 align:start position:0%
there's one crucial difference it occurs
 

00:01:30.369 --> 00:01:33.599 align:start position:0%
there's one crucial difference it occurs
before<00:01:30.670><c> your</c><00:01:31.240><c> code</c><00:01:31.479><c> runs</c><00:01:31.840><c> that</c><00:01:32.770><c> is</c><00:01:32.979><c> before</c><00:01:33.520><c> it</c>

00:01:33.599 --> 00:01:33.609 align:start position:0%
before your code runs that is before it
 

00:01:33.609 --> 00:01:36.660 align:start position:0%
before your code runs that is before it
can<00:01:33.759><c> do</c><00:01:34.030><c> any</c><00:01:34.270><c> damage</c><00:01:34.770><c> but</c><00:01:35.770><c> simple</c><00:01:36.100><c> types</c><00:01:36.310><c> are</c>

00:01:36.660 --> 00:01:36.670 align:start position:0%
can do any damage but simple types are
 

00:01:36.670 --> 00:01:38.910 align:start position:0%
can do any damage but simple types are
kind<00:01:36.969><c> of</c><00:01:37.030><c> inflexible</c><00:01:37.600><c> this</c><00:01:38.229><c> function</c><00:01:38.619><c> only</c>

00:01:38.910 --> 00:01:38.920 align:start position:0%
kind of inflexible this function only
 

00:01:38.920 --> 00:01:40.469 align:start position:0%
kind of inflexible this function only
works<00:01:39.250><c> for</c><00:01:39.430><c> arrays</c><00:01:39.670><c> that</c><00:01:39.700><c> contain</c><00:01:39.880><c> integers</c>

00:01:40.469 --> 00:01:40.479 align:start position:0%
works for arrays that contain integers
 

00:01:40.479 --> 00:01:42.990 align:start position:0%
works for arrays that contain integers
if<00:01:41.320><c> we</c><00:01:41.590><c> want</c><00:01:41.740><c> different</c><00:01:41.890><c> array</c><00:01:42.219><c> contents</c><00:01:42.789><c> in</c><00:01:42.939><c> a</c>

00:01:42.990 --> 00:01:43.000 align:start position:0%
if we want different array contents in a
 

00:01:43.000 --> 00:01:44.219 align:start position:0%
if we want different array contents in a
simply<00:01:43.329><c> type</c><00:01:43.509><c> language</c><00:01:43.899><c> we</c><00:01:44.079><c> need</c><00:01:44.170><c> a</c>

00:01:44.219 --> 00:01:44.229 align:start position:0%
simply type language we need a
 

00:01:44.229 --> 00:01:46.709 align:start position:0%
simply type language we need a
copy/paste<00:01:44.799><c> lots</c><00:01:45.070><c> of</c><00:01:45.189><c> boilerplate</c><00:01:45.630><c> lots</c><00:01:46.630><c> of</c>

00:01:46.709 --> 00:01:46.719 align:start position:0%
copy/paste lots of boilerplate lots of
 

00:01:46.719 --> 00:01:47.999 align:start position:0%
copy/paste lots of boilerplate lots of
languages<00:01:47.079><c> try</c><00:01:47.229><c> to</c><00:01:47.289><c> solve</c><00:01:47.530><c> this</c><00:01:47.679><c> with</c><00:01:47.859><c> things</c>

00:01:47.999 --> 00:01:48.009 align:start position:0%
languages try to solve this with things
 

00:01:48.009 --> 00:01:50.870 align:start position:0%
languages try to solve this with things
like<00:01:48.130><c> interfaces</c><00:01:48.729><c> but</c><00:01:49.149><c> there's</c><00:01:49.329><c> a</c><00:01:49.390><c> better</c><00:01:49.509><c> way</c>

00:01:50.870 --> 00:01:50.880 align:start position:0%
like interfaces but there's a better way
 

00:01:50.880 --> 00:01:53.069 align:start position:0%
like interfaces but there's a better way
polymorphism<00:01:51.880><c> allows</c><00:01:52.060><c> us</c><00:01:52.570><c> to</c><00:01:52.689><c> have</c><00:01:52.810><c> a</c><00:01:52.840><c> type</c>

00:01:53.069 --> 00:01:53.079 align:start position:0%
polymorphism allows us to have a type
 

00:01:53.079 --> 00:01:55.380 align:start position:0%
polymorphism allows us to have a type
parameter<00:01:53.259><c> a</c><00:01:53.740><c> that</c><00:01:54.340><c> can</c><00:01:54.460><c> get</c><00:01:54.609><c> filled</c><00:01:54.880><c> with</c><00:01:55.090><c> int</c>

00:01:55.380 --> 00:01:55.390 align:start position:0%
parameter a that can get filled with int
 

00:01:55.390 --> 00:01:58.380 align:start position:0%
parameter a that can get filled with int
or<00:01:55.539><c> string</c><00:01:55.600><c> or</c><00:01:56.409><c> any</c><00:01:56.740><c> type</c><00:01:56.979><c> that</c><00:01:57.009><c> we</c><00:01:57.189><c> like</c><00:01:57.390><c> this</c>

00:01:58.380 --> 00:01:58.390 align:start position:0%
or string or any type that we like this
 

00:01:58.390 --> 00:02:00.359 align:start position:0%
or string or any type that we like this
is<00:01:58.509><c> really</c><00:01:58.869><c> useful</c><00:01:59.320><c> and</c><00:01:59.500><c> most</c><00:01:59.799><c> type</c><00:01:59.979><c> languages</c>

00:02:00.359 --> 00:02:00.369 align:start position:0%
is really useful and most type languages
 

00:02:00.369 --> 00:02:01.859 align:start position:0%
is really useful and most type languages
stop<00:02:00.579><c> there</c><00:02:00.820><c> but</c><00:02:01.539><c> this</c><00:02:01.630><c> still</c><00:02:01.810><c> doesn't</c>

00:02:01.859 --> 00:02:01.869 align:start position:0%
stop there but this still doesn't
 

00:02:01.869 --> 00:02:05.580 align:start position:0%
stop there but this still doesn't
prevent<00:02:02.350><c> all</c><00:02:02.560><c> runtime</c><00:02:03.219><c> errors</c><00:02:04.259><c> we</c><00:02:05.259><c> could</c><00:02:05.409><c> call</c>

00:02:05.580 --> 00:02:05.590 align:start position:0%
prevent all runtime errors we could call
 

00:02:05.590 --> 00:02:07.620 align:start position:0%
prevent all runtime errors we could call
get<00:02:05.799><c> with</c><00:02:05.920><c> a</c><00:02:05.950><c> really</c><00:02:06.340><c> large</c><00:02:06.490><c> index</c><00:02:07.090><c> and</c><00:02:07.329><c> cause</c>

00:02:07.620 --> 00:02:07.630 align:start position:0%
get with a really large index and cause
 

00:02:07.630 --> 00:02:09.960 align:start position:0%
get with a really large index and cause
an<00:02:07.810><c> out-of-bounds</c><00:02:08.200><c> runtime</c><00:02:08.679><c> error</c><00:02:08.970><c> some</c>

00:02:09.960 --> 00:02:09.970 align:start position:0%
an out-of-bounds runtime error some
 

00:02:09.970 --> 00:02:11.370 align:start position:0%
an out-of-bounds runtime error some
languages<00:02:10.420><c> don't</c><00:02:10.539><c> even</c><00:02:10.780><c> error</c><00:02:10.990><c> they</c><00:02:11.200><c> just</c>

00:02:11.370 --> 00:02:11.380 align:start position:0%
languages don't even error they just
 

00:02:11.380 --> 00:02:12.899 align:start position:0%
languages don't even error they just
dump<00:02:11.680><c> the</c><00:02:11.920><c> contents</c><00:02:12.100><c> of</c><00:02:12.370><c> memory</c><00:02:12.670><c> and</c><00:02:12.819><c> that's</c>

00:02:12.899 --> 00:02:12.909 align:start position:0%
dump the contents of memory and that's
 

00:02:12.909 --> 00:02:15.960 align:start position:0%
dump the contents of memory and that's
probably<00:02:13.180><c> worse</c><00:02:14.280><c> but</c><00:02:15.280><c> for</c><00:02:15.430><c> what</c><00:02:15.550><c> the</c><00:02:15.610><c> compiler</c>

00:02:15.960 --> 00:02:15.970 align:start position:0%
probably worse but for what the compiler
 

00:02:15.970 --> 00:02:17.940 align:start position:0%
probably worse but for what the compiler
to<00:02:16.000><c> warn</c><00:02:16.300><c> us</c><00:02:16.450><c> if</c><00:02:16.659><c> our</c><00:02:16.810><c> index</c><00:02:17.440><c> is</c><00:02:17.590><c> bigger</c><00:02:17.769><c> than</c>

00:02:17.940 --> 00:02:17.950 align:start position:0%
to warn us if our index is bigger than
 

00:02:17.950 --> 00:02:18.720 align:start position:0%
to warn us if our index is bigger than
our

00:02:18.720 --> 00:02:18.730 align:start position:0%
our
 

00:02:18.730 --> 00:02:20.040 align:start position:0%
our
we're<00:02:18.910><c> gonna</c><00:02:19.000><c> need</c><00:02:19.240><c> types</c><00:02:19.540><c> that</c><00:02:19.660><c> depend</c><00:02:19.990><c> not</c>

00:02:20.040 --> 00:02:20.050 align:start position:0%
we're gonna need types that depend not
 

00:02:20.050 --> 00:02:23.660 align:start position:0%
we're gonna need types that depend not
only<00:02:20.170><c> on</c><00:02:20.470><c> other</c><00:02:20.590><c> types</c><00:02:20.950><c> but</c><00:02:21.580><c> on</c><00:02:21.670><c> normal</c><00:02:22.030><c> values</c>

00:02:23.660 --> 00:02:23.670 align:start position:0%
only on other types but on normal values
 

00:02:23.670 --> 00:02:26.580 align:start position:0%
only on other types but on normal values
here<00:02:24.670><c> we</c><00:02:24.819><c> have</c><00:02:25.000><c> a</c><00:02:25.030><c> type</c><00:02:25.390><c> type</c><00:02:25.930><c> level</c><00:02:26.110><c> number</c><00:02:26.440><c> n</c>

00:02:26.580 --> 00:02:26.590 align:start position:0%
here we have a type type level number n
 

00:02:26.590 --> 00:02:28.710 align:start position:0%
here we have a type type level number n
that<00:02:27.370><c> tells</c><00:02:27.580><c> the</c><00:02:27.700><c> compiler</c><00:02:27.970><c> how</c><00:02:28.330><c> long</c><00:02:28.569><c> the</c>

00:02:28.710 --> 00:02:28.720 align:start position:0%
that tells the compiler how long the
 

00:02:28.720 --> 00:02:30.870 align:start position:0%
that tells the compiler how long the
array<00:02:28.930><c> is</c><00:02:29.110><c> just</c><00:02:29.370><c> like</c><00:02:30.370><c> we</c><00:02:30.490><c> have</c><00:02:30.610><c> a</c><00:02:30.640><c> type</c>

00:02:30.870 --> 00:02:30.880 align:start position:0%
array is just like we have a type
 

00:02:30.880 --> 00:02:32.520 align:start position:0%
array is just like we have a type
parameter<00:02:31.030><c> a</c><00:02:31.450><c> that</c><00:02:31.750><c> tells</c><00:02:31.930><c> us</c><00:02:32.050><c> what's</c><00:02:32.230><c> in</c><00:02:32.410><c> the</c>

00:02:32.520 --> 00:02:32.530 align:start position:0%
parameter a that tells us what's in the
 

00:02:32.530 --> 00:02:35.640 align:start position:0%
parameter a that tells us what's in the
array<00:02:32.770><c> n</c><00:02:33.010><c> is</c><00:02:33.730><c> a</c><00:02:33.760><c> type</c><00:02:34.090><c> level</c><00:02:34.270><c> value</c><00:02:34.810><c> that</c><00:02:35.470><c> lets</c>

00:02:35.640 --> 00:02:35.650 align:start position:0%
array n is a type level value that lets
 

00:02:35.650 --> 00:02:37.020 align:start position:0%
array n is a type level value that lets
us<00:02:35.770><c> enforce</c><00:02:36.130><c> that</c><00:02:36.250><c> our</c><00:02:36.340><c> index</c><00:02:36.670><c> has</c><00:02:36.850><c> to</c><00:02:36.880><c> be</c>

00:02:37.020 --> 00:02:37.030 align:start position:0%
us enforce that our index has to be
 

00:02:37.030 --> 00:02:40.680 align:start position:0%
us enforce that our index has to be
between<00:02:37.239><c> 0</c><00:02:37.450><c> and</c><00:02:38.050><c> n</c><00:02:38.170><c> minus</c><00:02:38.200><c> 1</c><00:02:39.330><c> the</c><00:02:40.330><c> values</c>

00:02:40.680 --> 00:02:40.690 align:start position:0%
between 0 and n minus 1 the values
 

00:02:40.690 --> 00:02:42.690 align:start position:0%
between 0 and n minus 1 the values
independent<00:02:41.260><c> types</c><00:02:41.470><c> don't</c><00:02:42.370><c> have</c><00:02:42.489><c> to</c><00:02:42.610><c> be</c>

00:02:42.690 --> 00:02:42.700 align:start position:0%
independent types don't have to be
 

00:02:42.700 --> 00:02:44.160 align:start position:0%
independent types don't have to be
constants<00:02:43.180><c> they</c><00:02:43.450><c> can</c><00:02:43.600><c> be</c><00:02:43.690><c> the</c><00:02:43.780><c> results</c><00:02:44.080><c> of</c>

00:02:44.160 --> 00:02:44.170 align:start position:0%
constants they can be the results of
 

00:02:44.170 --> 00:02:46.590 align:start position:0%
constants they can be the results of
computations<00:02:44.790><c> this</c><00:02:45.790><c> lets</c><00:02:46.000><c> us</c><00:02:46.060><c> constrain</c><00:02:46.480><c> the</c>

00:02:46.590 --> 00:02:46.600 align:start position:0%
computations this lets us constrain the
 

00:02:46.600 --> 00:02:48.720 align:start position:0%
computations this lets us constrain the
function<00:02:46.930><c> so</c><00:02:47.170><c> much</c><00:02:47.380><c> that</c><00:02:48.040><c> we</c><00:02:48.130><c> can</c><00:02:48.250><c> often</c><00:02:48.520><c> guess</c>

00:02:48.720 --> 00:02:48.730 align:start position:0%
function so much that we can often guess
 

00:02:48.730 --> 00:02:50.400 align:start position:0%
function so much that we can often guess
what<00:02:48.940><c> the</c><00:02:49.030><c> implementation</c><00:02:49.660><c> has</c><00:02:49.840><c> to</c><00:02:49.989><c> be</c><00:02:50.110><c> just</c>

00:02:50.400 --> 00:02:50.410 align:start position:0%
what the implementation has to be just
 

00:02:50.410 --> 00:02:52.259 align:start position:0%
what the implementation has to be just
from<00:02:50.560><c> its</c><00:02:50.650><c> shape</c><00:02:50.920><c> kind</c><00:02:51.820><c> of</c><00:02:51.880><c> like</c><00:02:52.000><c> a</c><00:02:52.030><c> game</c><00:02:52.239><c> of</c>

00:02:52.259 --> 00:02:52.269 align:start position:0%
from its shape kind of like a game of
 

00:02:52.269 --> 00:02:54.240 align:start position:0%
from its shape kind of like a game of
who's<00:02:52.510><c> that</c><00:02:52.540><c> Pokemon</c><00:02:53.170><c> but</c><00:02:53.440><c> with</c><00:02:53.590><c> types</c><00:02:53.830><c> in</c>

00:02:54.240 --> 00:02:54.250 align:start position:0%
who's that Pokemon but with types in
 

00:02:54.250 --> 00:02:55.860 align:start position:0%
who's that Pokemon but with types in
this<00:02:55.120><c> case</c><00:02:55.300><c> we</c><00:02:55.420><c> have</c><00:02:55.510><c> a</c><00:02:55.570><c> function</c><00:02:55.840><c> that</c>

00:02:55.860 --> 00:02:55.870 align:start position:0%
this case we have a function that
 

00:02:55.870 --> 00:02:57.780 align:start position:0%
this case we have a function that
receives<00:02:56.200><c> a</c><00:02:56.290><c> number</c><00:02:56.560><c> n</c><00:02:56.709><c> and</c><00:02:56.980><c> returns</c><00:02:57.610><c> an</c><00:02:57.730><c> array</c>

00:02:57.780 --> 00:02:57.790 align:start position:0%
receives a number n and returns an array
 

00:02:57.790 --> 00:02:59.400 align:start position:0%
receives a number n and returns an array
of<00:02:57.940><c> prime</c><00:02:58.300><c> numbers</c><00:02:58.660><c> that</c><00:02:58.840><c> have</c><00:02:59.050><c> multiplied</c>

00:02:59.400 --> 00:02:59.410 align:start position:0%
of prime numbers that have multiplied
 

00:02:59.410 --> 00:03:02.009 align:start position:0%
of prime numbers that have multiplied
together<00:02:59.560><c> equal</c><00:03:00.310><c> n</c><00:03:00.540><c> Karen</c><00:03:01.540><c> can</c><00:03:01.690><c> anyone</c><00:03:01.870><c> guess</c>

00:03:02.009 --> 00:03:02.019 align:start position:0%
together equal n Karen can anyone guess
 

00:03:02.019 --> 00:03:05.070 align:start position:0%
together equal n Karen can anyone guess
what<00:03:02.140><c> this</c><00:03:02.290><c> has</c><00:03:02.410><c> to</c><00:03:02.440><c> be</c><00:03:02.880><c> it's</c><00:03:03.880><c> factorize</c><00:03:04.330><c> the</c>

00:03:05.070 --> 00:03:05.080 align:start position:0%
what this has to be it's factorize the
 

00:03:05.080 --> 00:03:06.330 align:start position:0%
what this has to be it's factorize the
cool<00:03:05.290><c> thing</c><00:03:05.440><c> is</c><00:03:05.470><c> nothing</c><00:03:05.860><c> other</c><00:03:06.040><c> than</c><00:03:06.160><c> the</c>

00:03:06.330 --> 00:03:06.340 align:start position:0%
cool thing is nothing other than the
 

00:03:06.340 --> 00:03:07.979 align:start position:0%
cool thing is nothing other than the
correct<00:03:06.550><c> factorization</c><00:03:06.989><c> implementation</c>

00:03:07.979 --> 00:03:07.989 align:start position:0%
correct factorization implementation
 

00:03:07.989 --> 00:03:09.870 align:start position:0%
correct factorization implementation
will<00:03:08.350><c> pass</c><00:03:08.530><c> the</c><00:03:08.680><c> type</c><00:03:08.830><c> checker</c><00:03:09.069><c> that</c><00:03:09.730><c> the</c>

00:03:09.870 --> 00:03:09.880 align:start position:0%
will pass the type checker that the
 

00:03:09.880 --> 00:03:11.430 align:start position:0%
will pass the type checker that the
Fibonacci<00:03:10.269><c> sequence</c><00:03:10.600><c> would</c><00:03:10.930><c> be</c><00:03:11.019><c> a</c><00:03:11.050><c> type</c><00:03:11.260><c> error</c>

00:03:11.430 --> 00:03:11.440 align:start position:0%
Fibonacci sequence would be a type error
 

00:03:11.440 --> 00:03:13.259 align:start position:0%
Fibonacci sequence would be a type error
because<00:03:11.950><c> the</c><00:03:12.130><c> products</c><00:03:12.489><c> wouldn't</c><00:03:12.760><c> sum</c><00:03:12.970><c> to</c><00:03:13.120><c> it</c>

00:03:13.259 --> 00:03:13.269 align:start position:0%
because the products wouldn't sum to it
 

00:03:13.269 --> 00:03:16.949 align:start position:0%
because the products wouldn't sum to it
to<00:03:13.480><c> the</c><00:03:13.630><c> number</c><00:03:13.870><c> let's</c><00:03:14.709><c> play</c><00:03:14.830><c> again</c><00:03:15.840><c> given</c><00:03:16.840><c> an</c>

00:03:16.949 --> 00:03:16.959 align:start position:0%
to the number let's play again given an
 

00:03:16.959 --> 00:03:19.979 align:start position:0%
to the number let's play again given an
array<00:03:17.080><c> X's</c><00:03:17.880><c> return</c><00:03:18.880><c> an</c><00:03:19.000><c> array</c><00:03:19.269><c> wise</c><00:03:19.510><c> with</c><00:03:19.900><c> the</c>

00:03:19.979 --> 00:03:19.989 align:start position:0%
array X's return an array wise with the
 

00:03:19.989 --> 00:03:21.750 align:start position:0%
array X's return an array wise with the
same<00:03:20.200><c> elements</c><00:03:20.440><c> but</c><00:03:20.830><c> in</c><00:03:21.190><c> ascending</c><00:03:21.489><c> order</c>

00:03:21.750 --> 00:03:21.760 align:start position:0%
same elements but in ascending order
 

00:03:21.760 --> 00:03:24.979 align:start position:0%
same elements but in ascending order
what<00:03:22.450><c> does</c><00:03:22.540><c> this</c><00:03:22.600><c> function</c><00:03:22.930><c> have</c><00:03:23.049><c> to</c><00:03:23.079><c> be</c><00:03:23.940><c> sort</c>

00:03:24.979 --> 00:03:24.989 align:start position:0%
what does this function have to be sort
 

00:03:24.989 --> 00:03:27.750 align:start position:0%
what does this function have to be sort
anything<00:03:25.989><c> else</c><00:03:26.110><c> is</c><00:03:26.260><c> a</c><00:03:26.290><c> type</c><00:03:26.500><c> error</c><00:03:26.650><c> those</c><00:03:27.519><c> such</c>

00:03:27.750 --> 00:03:27.760 align:start position:0%
anything else is a type error those such
 

00:03:27.760 --> 00:03:29.520 align:start position:0%
anything else is a type error those such
that<00:03:27.970><c> to</c><00:03:28.120><c> check</c><00:03:28.299><c> statically</c><00:03:28.840><c> which</c><00:03:29.290><c> means</c>

00:03:29.520 --> 00:03:29.530 align:start position:0%
that to check statically which means
 

00:03:29.530 --> 00:03:31.259 align:start position:0%
that to check statically which means
that<00:03:29.950><c> you</c><00:03:30.400><c> will</c><00:03:30.549><c> not</c><00:03:30.640><c> go</c><00:03:30.790><c> to</c><00:03:30.820><c> space</c><00:03:31.120><c> today</c>

00:03:31.259 --> 00:03:31.269 align:start position:0%
that you will not go to space today
 

00:03:31.269 --> 00:03:33.449 align:start position:0%
that you will not go to space today
becomes<00:03:32.079><c> my</c><00:03:32.530><c> code</c><00:03:32.739><c> is</c><00:03:32.890><c> broken</c><00:03:33.010><c> and</c><00:03:33.370><c> I</c><00:03:33.400><c> don't</c>

00:03:33.449 --> 00:03:33.459 align:start position:0%
becomes my code is broken and I don't
 

00:03:33.459 --> 00:03:35.670 align:start position:0%
becomes my code is broken and I don't
know<00:03:33.730><c> why</c><00:03:33.910><c> which</c><00:03:34.690><c> is</c><00:03:34.720><c> great</c><00:03:34.989><c> because</c><00:03:35.200><c> compile</c>

00:03:35.670 --> 00:03:35.680 align:start position:0%
know why which is great because compile
 

00:03:35.680 --> 00:03:37.680 align:start position:0%
know why which is great because compile
time<00:03:35.980><c> is</c><00:03:36.190><c> when</c><00:03:36.370><c> you</c><00:03:36.549><c> the</c><00:03:36.700><c> programmer</c><00:03:37.150><c> are</c><00:03:37.420><c> in</c>

00:03:37.680 --> 00:03:37.690 align:start position:0%
time is when you the programmer are in
 

00:03:37.690 --> 00:03:40.140 align:start position:0%
time is when you the programmer are in
the<00:03:37.750><c> process</c><00:03:37.930><c> of</c><00:03:38.200><c> fixing</c><00:03:38.350><c> your</c><00:03:38.560><c> code</c><00:03:38.970><c> this</c><00:03:39.970><c> is</c>

00:03:40.140 --> 00:03:40.150 align:start position:0%
the process of fixing your code this is
 

00:03:40.150 --> 00:03:41.789 align:start position:0%
the process of fixing your code this is
really<00:03:40.480><c> nice</c><00:03:40.630><c> for</c><00:03:40.690><c> immutable</c><00:03:41.350><c> block</c><00:03:41.530><c> chains</c>

00:03:41.789 --> 00:03:41.799 align:start position:0%
really nice for immutable block chains
 

00:03:41.799 --> 00:03:44.160 align:start position:0%
really nice for immutable block chains
where<00:03:42.340><c> a</c><00:03:42.519><c> runtime</c><00:03:42.910><c> error</c><00:03:42.970><c> means</c><00:03:43.510><c> my</c><00:03:43.840><c> code</c><00:03:44.049><c> is</c>

00:03:44.160 --> 00:03:44.170 align:start position:0%
where a runtime error means my code is
 

00:03:44.170 --> 00:03:45.870 align:start position:0%
where a runtime error means my code is
broken<00:03:44.440><c> no</c><00:03:45.100><c> one</c><00:03:45.220><c> can</c><00:03:45.370><c> get</c><00:03:45.489><c> their</c><00:03:45.610><c> money</c><00:03:45.790><c> out</c>

00:03:45.870 --> 00:03:45.880 align:start position:0%
broken no one can get their money out
 

00:03:45.880 --> 00:03:48.090 align:start position:0%
broken no one can get their money out
and<00:03:46.150><c> I</c><00:03:46.450><c> can't</c><00:03:46.690><c> fix</c><00:03:46.870><c> it</c><00:03:47.079><c> because</c><00:03:47.620><c> I</c><00:03:47.650><c> deployed</c><00:03:48.070><c> my</c>

00:03:48.090 --> 00:03:48.100 align:start position:0%
and I can't fix it because I deployed my
 

00:03:48.100 --> 00:03:51.870 align:start position:0%
and I can't fix it because I deployed my
code<00:03:48.459><c> to</c><00:03:48.489><c> an</c><00:03:48.760><c> immutable</c><00:03:49.180><c> platform</c><00:03:50.880><c> but</c>

00:03:51.870 --> 00:03:51.880 align:start position:0%
code to an immutable platform but
 

00:03:51.880 --> 00:03:53.520 align:start position:0%
code to an immutable platform but
dependent<00:03:52.239><c> types</c><00:03:52.329><c> are</c><00:03:52.540><c> useful</c><00:03:52.840><c> for</c><00:03:52.870><c> so</c><00:03:53.350><c> much</c>

00:03:53.520 --> 00:03:53.530 align:start position:0%
dependent types are useful for so much
 

00:03:53.530 --> 00:03:55.590 align:start position:0%
dependent types are useful for so much
more<00:03:53.799><c> if</c><00:03:54.040><c> we</c><00:03:54.310><c> can</c><00:03:54.370><c> do</c><00:03:54.489><c> arbitrary</c><00:03:55.120><c> type</c><00:03:55.420><c> level</c>

00:03:55.590 --> 00:03:55.600 align:start position:0%
more if we can do arbitrary type level
 

00:03:55.600 --> 00:03:57.360 align:start position:0%
more if we can do arbitrary type level
computation<00:03:56.320><c> we</c><00:03:56.739><c> can</c><00:03:56.890><c> use</c><00:03:57.010><c> our</c><00:03:57.130><c> type</c><00:03:57.340><c> system</c>

00:03:57.360 --> 00:03:57.370 align:start position:0%
computation we can use our type system
 

00:03:57.370 --> 00:04:00.060 align:start position:0%
computation we can use our type system
to<00:03:58.090><c> declare</c><00:03:58.390><c> any</c><00:03:58.600><c> number</c><00:03:58.900><c> of</c><00:03:58.989><c> any</c><00:03:59.470><c> combination</c>

00:04:00.060 --> 00:04:00.070 align:start position:0%
to declare any number of any combination
 

00:04:00.070 --> 00:04:02.130 align:start position:0%
to declare any number of any combination
of<00:04:00.130><c> properties</c><00:04:00.340><c> we</c><00:04:00.670><c> want</c><00:04:00.820><c> and</c><00:04:01.120><c> then</c><00:04:01.959><c> if</c><00:04:02.049><c> we</c>

00:04:02.130 --> 00:04:02.140 align:start position:0%
of properties we want and then if we
 

00:04:02.140 --> 00:04:03.599 align:start position:0%
of properties we want and then if we
write<00:04:02.290><c> code</c><00:04:02.500><c> that</c><00:04:02.530><c> validly</c><00:04:03.010><c> checks</c><00:04:03.310><c> as</c><00:04:03.459><c> those</c>

00:04:03.599 --> 00:04:03.609 align:start position:0%
write code that validly checks as those
 

00:04:03.609 --> 00:04:05.340 align:start position:0%
write code that validly checks as those
properties<00:04:04.030><c> we've</c><00:04:04.540><c> built</c><00:04:04.720><c> a</c><00:04:04.810><c> constructive</c>

00:04:05.340 --> 00:04:05.350 align:start position:0%
properties we've built a constructive
 

00:04:05.350 --> 00:04:07.050 align:start position:0%
properties we've built a constructive
executable<00:04:05.980><c> proof</c><00:04:06.280><c> of</c><00:04:06.489><c> the</c><00:04:06.670><c> theorem</c><00:04:06.850><c> that</c>

00:04:07.050 --> 00:04:07.060 align:start position:0%
executable proof of the theorem that
 

00:04:07.060 --> 00:04:09.300 align:start position:0%
executable proof of the theorem that
type<00:04:07.209><c> represents</c><00:04:07.560><c> this</c><00:04:08.560><c> is</c><00:04:08.709><c> the</c><00:04:08.799><c> curry</c><00:04:08.980><c> Howard</c>

00:04:09.300 --> 00:04:09.310 align:start position:0%
type represents this is the curry Howard
 

00:04:09.310 --> 00:04:11.729 align:start position:0%
type represents this is the curry Howard
isomorphism<00:04:10.000><c> and</c><00:04:10.299><c> by</c><00:04:10.450><c> favorite</c><00:04:10.900><c> isomorphism</c>

00:04:11.729 --> 00:04:11.739 align:start position:0%
isomorphism and by favorite isomorphism
 

00:04:11.739 --> 00:04:13.620 align:start position:0%
isomorphism and by favorite isomorphism
formal<00:04:12.670><c> logic</c><00:04:12.940><c> and</c><00:04:13.060><c> software</c><00:04:13.299><c> development</c>

00:04:13.620 --> 00:04:13.630 align:start position:0%
formal logic and software development
 

00:04:13.630 --> 00:04:15.300 align:start position:0%
formal logic and software development
are<00:04:13.810><c> actually</c><00:04:14.079><c> the</c><00:04:14.170><c> same</c><00:04:14.200><c> activity</c><00:04:14.859><c> it's</c><00:04:15.100><c> just</c>

00:04:15.300 --> 00:04:15.310 align:start position:0%
are actually the same activity it's just
 

00:04:15.310 --> 00:04:16.979 align:start position:0%
are actually the same activity it's just
not<00:04:15.430><c> obvious</c><00:04:15.609><c> because</c><00:04:16.090><c> the</c><00:04:16.180><c> usual</c><00:04:16.299><c> syntax</c><00:04:16.840><c> is</c>

00:04:16.979 --> 00:04:16.989 align:start position:0%
not obvious because the usual syntax is
 

00:04:16.989 --> 00:04:19.500 align:start position:0%
not obvious because the usual syntax is
very<00:04:17.169><c> different</c><00:04:17.590><c> most</c><00:04:18.400><c> math</c><00:04:18.609><c> syntax</c><00:04:19.060><c> forces</c>

00:04:19.500 --> 00:04:19.510 align:start position:0%
very different most math syntax forces
 

00:04:19.510 --> 00:04:21.029 align:start position:0%
very different most math syntax forces
you<00:04:19.600><c> to</c><00:04:19.630><c> do</c><00:04:19.810><c> the</c><00:04:19.900><c> execution</c><00:04:20.440><c> manually</c><00:04:20.859><c> and</c>

00:04:21.029 --> 00:04:21.039 align:start position:0%
you to do the execution manually and
 

00:04:21.039 --> 00:04:22.950 align:start position:0%
you to do the execution manually and
most<00:04:21.609><c> code</c><00:04:21.820><c> syntax</c><00:04:22.090><c> forces</c><00:04:22.630><c> you</c><00:04:22.690><c> to</c><00:04:22.720><c> keep</c>

00:04:22.950 --> 00:04:22.960 align:start position:0%
most code syntax forces you to keep
 

00:04:22.960 --> 00:04:26.159 align:start position:0%
most code syntax forces you to keep
track<00:04:23.200><c> of</c><00:04:23.350><c> type</c><00:04:23.530><c> information</c><00:04:23.860><c> manually</c><00:04:25.169><c> our</c>

00:04:26.159 --> 00:04:26.169 align:start position:0%
track of type information manually our
 

00:04:26.169 --> 00:04:27.390 align:start position:0%
track of type information manually our
goal<00:04:26.409><c> with</c><00:04:26.560><c> formality</c><00:04:27.010><c> is</c><00:04:27.099><c> to</c><00:04:27.220><c> have</c><00:04:27.370><c> a</c>

00:04:27.390 --> 00:04:27.400 align:start position:0%
goal with formality is to have a
 

00:04:27.400 --> 00:04:29.100 align:start position:0%
goal with formality is to have a
language<00:04:27.640><c> that's</c><00:04:27.970><c> really</c><00:04:28.360><c> really</c><00:04:28.599><c> good</c><00:04:28.900><c> for</c>

00:04:29.100 --> 00:04:29.110 align:start position:0%
language that's really really good for
 

00:04:29.110 --> 00:04:30.960 align:start position:0%
language that's really really good for
both<00:04:29.289><c> software</c><00:04:29.770><c> development</c><00:04:30.220><c> and</c><00:04:30.340><c> for</c>

00:04:30.960 --> 00:04:30.970 align:start position:0%
both software development and for
 

00:04:30.970 --> 00:04:31.920 align:start position:0%
both software development and for
exploring<00:04:31.360><c> mathematics</c>

00:04:31.920 --> 00:04:31.930 align:start position:0%
exploring mathematics
 

00:04:31.930 --> 00:04:33.600 align:start position:0%
exploring mathematics
we<00:04:32.500><c> want</c><00:04:32.680><c> to</c><00:04:32.740><c> make</c><00:04:32.860><c> a</c><00:04:32.889><c> programming</c><00:04:33.370><c> language</c>

00:04:33.600 --> 00:04:33.610 align:start position:0%
we want to make a programming language
 

00:04:33.610 --> 00:04:35.189 align:start position:0%
we want to make a programming language
as<00:04:33.699><c> accessible</c><00:04:34.300><c> as</c><00:04:34.419><c> Python</c><00:04:34.630><c> and</c><00:04:34.960><c> a</c><00:04:34.990><c> proof</c>

00:04:35.189 --> 00:04:35.199 align:start position:0%
as accessible as Python and a proof
 

00:04:35.199 --> 00:04:37.230 align:start position:0%
as accessible as Python and a proof
language<00:04:35.560><c> as</c><00:04:35.680><c> powerful</c><00:04:36.130><c> as</c><00:04:36.220><c> Agda</c><00:04:36.639><c> one</c><00:04:37.030><c> that's</c>

00:04:37.230 --> 00:04:37.240 align:start position:0%
language as powerful as Agda one that's
 

00:04:37.240 --> 00:04:40.680 align:start position:0%
language as powerful as Agda one that's
safe<00:04:37.509><c> fast</c><00:04:38.199><c> simple</c><00:04:38.889><c> and</c><00:04:39.100><c> portable</c><00:04:39.790><c> we</c><00:04:40.509><c> still</c>

00:04:40.680 --> 00:04:40.690 align:start position:0%
safe fast simple and portable we still
 

00:04:40.690 --> 00:04:41.999 align:start position:0%
safe fast simple and portable we still
have<00:04:40.780><c> a</c><00:04:40.810><c> long</c><00:04:40.930><c> way</c><00:04:41.080><c> to</c><00:04:41.139><c> meet</c><00:04:41.289><c> that</c><00:04:41.320><c> goal</c><00:04:41.650><c> but</c>

00:04:41.999 --> 00:04:42.009 align:start position:0%
have a long way to meet that goal but
 

00:04:42.009 --> 00:04:43.230 align:start position:0%
have a long way to meet that goal but
we've<00:04:42.130><c> made</c><00:04:42.220><c> great</c><00:04:42.430><c> progress</c><00:04:42.639><c> in</c><00:04:43.000><c> the</c><00:04:43.060><c> past</c>

00:04:43.230 --> 00:04:43.240 align:start position:0%
we've made great progress in the past
 

00:04:43.240 --> 00:04:45.629 align:start position:0%
we've made great progress in the past
year<00:04:43.770><c> here's</c><00:04:44.770><c> all</c><00:04:44.889><c> the</c><00:04:44.979><c> type</c><00:04:45.130><c> signatures</c><00:04:45.520><c> we</c>

00:04:45.629 --> 00:04:45.639 align:start position:0%
year here's all the type signatures we
 

00:04:45.639 --> 00:04:47.520 align:start position:0%
year here's all the type signatures we
just<00:04:45.820><c> went</c><00:04:45.940><c> over</c><00:04:46.240><c> but</c><00:04:46.570><c> informality</c><00:04:46.960><c> syntax</c>

00:04:47.520 --> 00:04:47.530 align:start position:0%
just went over but informality syntax
 

00:04:47.530 --> 00:04:51.689 align:start position:0%
just went over but informality syntax
instead<00:04:47.800><c> instead</c><00:04:48.190><c> of</c><00:04:48.430><c> pseudocode</c><00:04:49.229><c> and</c><00:04:50.699><c> here's</c>

00:04:51.689 --> 00:04:51.699 align:start position:0%
instead instead of pseudocode and here's
 

00:04:51.699 --> 00:04:53.370 align:start position:0%
instead instead of pseudocode and here's
how<00:04:51.820><c> we</c><00:04:51.910><c> declare</c><00:04:52.180><c> datatypes</c><00:04:52.690><c> and</c><00:04:52.900><c> how</c><00:04:53.110><c> we</c><00:04:53.169><c> take</c>

00:04:53.370 --> 00:04:53.380 align:start position:0%
how we declare datatypes and how we take
 

00:04:53.380 --> 00:04:55.409 align:start position:0%
how we declare datatypes and how we take
the<00:04:53.500><c> tail</c><00:04:53.680><c> of</c><00:04:53.830><c> a</c><00:04:53.889><c> list</c><00:04:54.070><c> the</c><00:04:55.000><c> cool</c><00:04:55.210><c> thing</c><00:04:55.389><c> here</c>

00:04:55.409 --> 00:04:55.419 align:start position:0%
the tail of a list the cool thing here
 

00:04:55.419 --> 00:04:57.060 align:start position:0%
the tail of a list the cool thing here
is<00:04:55.810><c> that</c><00:04:55.840><c> unlike</c><00:04:56.080><c> other</c><00:04:56.320><c> proof</c><00:04:56.620><c> languages</c>

00:04:57.060 --> 00:04:57.070 align:start position:0%
is that unlike other proof languages
 

00:04:57.070 --> 00:05:00.689 align:start position:0%
is that unlike other proof languages
like<00:04:57.520><c> or</c><00:04:57.759><c> Agda</c><00:04:58.500><c> our</c><00:04:59.500><c> data</c><00:04:59.949><c> types</c><00:05:00.250><c> aren't</c>

00:05:00.689 --> 00:05:00.699 align:start position:0%
like or Agda our data types aren't
 

00:05:00.699 --> 00:05:02.670 align:start position:0%
like or Agda our data types aren't
built<00:05:00.970><c> in</c><00:05:01.240><c> to</c><00:05:01.509><c> the</c><00:05:01.600><c> theory</c><00:05:01.840><c> they're</c><00:05:02.350><c> actually</c>

00:05:02.670 --> 00:05:02.680 align:start position:0%
built in to the theory they're actually
 

00:05:02.680 --> 00:05:05.420 align:start position:0%
built in to the theory they're actually
just<00:05:02.830><c> a</c><00:05:02.889><c> syntax</c><00:05:03.280><c> sugar</c><00:05:03.490><c> for</c><00:05:04.120><c> lambda</c><00:05:04.750><c> functions</c>

00:05:05.420 --> 00:05:05.430 align:start position:0%
just a syntax sugar for lambda functions
 

00:05:05.430 --> 00:05:07.710 align:start position:0%
just a syntax sugar for lambda functions
this<00:05:06.430><c> this</c><00:05:06.760><c> code</c><00:05:06.940><c> looks</c><00:05:07.060><c> a</c><00:05:07.180><c> little</c><00:05:07.270><c> scary</c><00:05:07.570><c> from</c>

00:05:07.710 --> 00:05:07.720 align:start position:0%
this this code looks a little scary from
 

00:05:07.720 --> 00:05:09.180 align:start position:0%
this this code looks a little scary from
a<00:05:07.810><c> user</c><00:05:07.960><c> perspective</c><00:05:08.139><c> which</c><00:05:08.560><c> is</c><00:05:08.680><c> why</c><00:05:08.800><c> we</c><00:05:08.979><c> built</c>

00:05:09.180 --> 00:05:09.190 align:start position:0%
a user perspective which is why we built
 

00:05:09.190 --> 00:05:10.650 align:start position:0%
a user perspective which is why we built
the<00:05:09.280><c> syntax</c><00:05:09.639><c> trigger</c><00:05:09.940><c> over</c><00:05:10.060><c> the</c><00:05:10.240><c> past</c><00:05:10.449><c> year</c>

00:05:10.650 --> 00:05:10.660 align:start position:0%
the syntax trigger over the past year
 

00:05:10.660 --> 00:05:12.689 align:start position:0%
the syntax trigger over the past year
but<00:05:11.650><c> it's</c><00:05:11.800><c> actually</c><00:05:12.039><c> a</c><00:05:12.070><c> lot</c><00:05:12.190><c> simpler</c><00:05:12.550><c> to</c>

00:05:12.689 --> 00:05:12.699 align:start position:0%
but it's actually a lot simpler to
 

00:05:12.699 --> 00:05:14.730 align:start position:0%
but it's actually a lot simpler to
implement<00:05:12.729><c> and</c><00:05:13.270><c> our</c><00:05:13.780><c> runtime</c><00:05:13.990><c> is</c><00:05:14.350><c> only</c><00:05:14.530><c> about</c>

00:05:14.730 --> 00:05:14.740 align:start position:0%
implement and our runtime is only about
 

00:05:14.740 --> 00:05:16.500 align:start position:0%
implement and our runtime is only about
400<00:05:15.190><c> lines</c><00:05:15.370><c> long</c><00:05:15.610><c> and</c><00:05:15.850><c> our</c><00:05:15.910><c> core</c><00:05:16.180><c> language</c>

00:05:16.500 --> 00:05:16.510 align:start position:0%
400 lines long and our core language
 

00:05:16.510 --> 00:05:18.659 align:start position:0%
400 lines long and our core language
theory<00:05:16.780><c> is</c><00:05:16.840><c> only</c><00:05:16.990><c> about</c><00:05:17.139><c> 1500</c><00:05:17.770><c> we</c><00:05:18.430><c> think</c><00:05:18.580><c> it's</c>

00:05:18.659 --> 00:05:18.669 align:start position:0%
theory is only about 1500 we think it's
 

00:05:18.669 --> 00:05:20.010 align:start position:0%
theory is only about 1500 we think it's
really<00:05:18.789><c> important</c><00:05:19.240><c> for</c><00:05:19.270><c> portability</c><00:05:19.930><c> and</c>

00:05:20.010 --> 00:05:20.020 align:start position:0%
really important for portability and
 

00:05:20.020 --> 00:05:22.529 align:start position:0%
really important for portability and
decentralization<00:05:20.850><c> to</c><00:05:21.850><c> have</c><00:05:22.030><c> a</c><00:05:22.060><c> language</c>

00:05:22.529 --> 00:05:22.539 align:start position:0%
decentralization to have a language
 

00:05:22.539 --> 00:05:23.909 align:start position:0%
decentralization to have a language
that's<00:05:22.720><c> small</c><00:05:23.050><c> enough</c><00:05:23.080><c> that</c><00:05:23.410><c> people</c><00:05:23.560><c> can</c>

00:05:23.909 --> 00:05:23.919 align:start position:0%
that's small enough that people can
 

00:05:23.919 --> 00:05:25.860 align:start position:0%
that's small enough that people can
implement<00:05:24.639><c> it</c><00:05:24.880><c> or</c><00:05:24.970><c> at</c><00:05:25.060><c> least</c><00:05:25.090><c> understand</c><00:05:25.690><c> it</c>

00:05:25.860 --> 00:05:25.870 align:start position:0%
implement it or at least understand it
 

00:05:25.870 --> 00:05:29.100 align:start position:0%
implement it or at least understand it
themselves<00:05:27.180><c> here's</c><00:05:28.180><c> the</c><00:05:28.300><c> clean</c><00:05:28.449><c> syntax</c><00:05:28.840><c> again</c>

00:05:29.100 --> 00:05:29.110 align:start position:0%
themselves here's the clean syntax again
 

00:05:29.110 --> 00:05:30.390 align:start position:0%
themselves here's the clean syntax again
you<00:05:29.410><c> know</c><00:05:29.500><c> now</c><00:05:29.650><c> that</c><00:05:29.680><c> you</c><00:05:29.860><c> know</c><00:05:29.949><c> the</c><00:05:30.070><c> laminin</c>

00:05:30.390 --> 00:05:30.400 align:start position:0%
you know now that you know the laminin
 

00:05:30.400 --> 00:05:33.120 align:start position:0%
you know now that you know the laminin
codings<00:05:30.699><c> look</c><00:05:30.820><c> like</c><00:05:31.949><c> let's</c><00:05:32.949><c> talk</c><00:05:33.039><c> about</c>

00:05:33.120 --> 00:05:33.130 align:start position:0%
codings look like let's talk about
 

00:05:33.130 --> 00:05:35.100 align:start position:0%
codings look like let's talk about
performance<00:05:33.639><c> a</c><00:05:33.849><c> language</c><00:05:34.599><c> is</c><00:05:34.720><c> great</c><00:05:34.840><c> for</c>

00:05:35.100 --> 00:05:35.110 align:start position:0%
performance a language is great for
 

00:05:35.110 --> 00:05:36.570 align:start position:0%
performance a language is great for
writing<00:05:35.169><c> practical</c><00:05:35.680><c> software</c><00:05:36.039><c> has</c><00:05:36.310><c> to</c><00:05:36.340><c> be</c>

00:05:36.570 --> 00:05:36.580 align:start position:0%
writing practical software has to be
 

00:05:36.580 --> 00:05:39.180 align:start position:0%
writing practical software has to be
fast<00:05:37.080><c> while</c><00:05:38.080><c> formalities</c><00:05:38.530><c> runtime</c><00:05:38.889><c> is</c><00:05:39.010><c> still</c>

00:05:39.180 --> 00:05:39.190 align:start position:0%
fast while formalities runtime is still
 

00:05:39.190 --> 00:05:40.710 align:start position:0%
fast while formalities runtime is still
immature<00:05:39.430><c> the</c><00:05:39.880><c> language</c><00:05:40.330><c> has</c><00:05:40.449><c> a</c><00:05:40.479><c> lot</c><00:05:40.690><c> of</c>

00:05:40.710 --> 00:05:40.720 align:start position:0%
immature the language has a lot of
 

00:05:40.720 --> 00:05:41.850 align:start position:0%
immature the language has a lot of
features<00:05:40.930><c> that</c><00:05:41.110><c> we</c><00:05:41.320><c> think</c><00:05:41.349><c> will</c><00:05:41.560><c> make</c><00:05:41.680><c> it</c><00:05:41.740><c> very</c>

00:05:41.850 --> 00:05:41.860 align:start position:0%
features that we think will make it very
 

00:05:41.860 --> 00:05:44.430 align:start position:0%
features that we think will make it very
fast<00:05:42.340><c> in</c><00:05:42.520><c> the</c><00:05:42.610><c> long</c><00:05:42.760><c> term</c><00:05:43.289><c> interaction</c><00:05:44.289><c> that's</c>

00:05:44.430 --> 00:05:44.440 align:start position:0%
fast in the long term interaction that's
 

00:05:44.440 --> 00:05:46.379 align:start position:0%
fast in the long term interaction that's
is<00:05:44.740><c> a</c><00:05:45.099><c> runtime</c><00:05:45.520><c> model</c><00:05:45.820><c> and</c><00:05:46.000><c> I</c><00:05:46.120><c> think</c><00:05:46.300><c> it</c>

00:05:46.379 --> 00:05:46.389 align:start position:0%
is a runtime model and I think it
 

00:05:46.389 --> 00:05:47.879 align:start position:0%
is a runtime model and I think it
deserves<00:05:46.449><c> its</c><00:05:46.750><c> own</c><00:05:46.810><c> talk</c><00:05:47.139><c> since</c><00:05:47.590><c> they</c><00:05:47.710><c> allow</c>

00:05:47.879 --> 00:05:47.889 align:start position:0%
deserves its own talk since they allow
 

00:05:47.889 --> 00:05:49.500 align:start position:0%
deserves its own talk since they allow
some<00:05:48.070><c> really</c><00:05:48.430><c> crazy</c><00:05:48.610><c> optimizations</c><00:05:49.419><c> like</c>

00:05:49.500 --> 00:05:49.510 align:start position:0%
some really crazy optimizations like
 

00:05:49.510 --> 00:05:51.870 align:start position:0%
some really crazy optimizations like
optimal<00:05:50.349><c> sharing</c><00:05:50.800><c> runtime</c><00:05:51.250><c> Fusion</c><00:05:51.669><c> and</c>

00:05:51.870 --> 00:05:51.880 align:start position:0%
optimal sharing runtime Fusion and
 

00:05:51.880 --> 00:05:55.290 align:start position:0%
optimal sharing runtime Fusion and
here's<00:05:52.449><c> our</c><00:05:52.630><c> nice</c><00:05:54.060><c> illustration</c><00:05:55.060><c> of</c><00:05:55.150><c> what</c>

00:05:55.290 --> 00:05:55.300 align:start position:0%
here's our nice illustration of what
 

00:05:55.300 --> 00:05:56.580 align:start position:0%
here's our nice illustration of what
like<00:05:55.479><c> the</c><00:05:55.599><c> reduction</c><00:05:56.020><c> actually</c><00:05:56.289><c> looks</c><00:05:56.470><c> like</c>

00:05:56.580 --> 00:05:56.590 align:start position:0%
like the reduction actually looks like
 

00:05:56.590 --> 00:05:58.020 align:start position:0%
like the reduction actually looks like
and<00:05:56.770><c> you</c><00:05:56.830><c> can</c><00:05:56.860><c> see</c><00:05:57.099><c> the</c><00:05:57.190><c> conversion</c><00:05:57.639><c> from</c><00:05:57.820><c> a</c>

00:05:58.020 --> 00:05:58.030 align:start position:0%
and you can see the conversion from a
 

00:05:58.030 --> 00:06:05.750 align:start position:0%
and you can see the conversion from a
lambda<00:05:58.419><c> X</c><00:05:58.539><c> term</c><00:05:58.930><c> to</c><00:05:59.229><c> a</c><00:05:59.500><c> graph</c><00:05:59.770><c> and</c><00:06:00.010><c> then</c><00:06:00.130><c> back</c>

00:06:05.750 --> 00:06:05.760 align:start position:0%
 
 

00:06:05.760 --> 00:06:07.980 align:start position:0%
 
for<00:06:06.760><c> code</c><00:06:06.909><c> with</c><00:06:07.090><c> higher-order</c><00:06:07.330><c> lots</c><00:06:07.900><c> of</c>

00:06:07.980 --> 00:06:07.990 align:start position:0%
for code with higher-order lots of
 

00:06:07.990 --> 00:06:09.149 align:start position:0%
for code with higher-order lots of
higher-order<00:06:08.229><c> functions</c><00:06:08.680><c> formalities</c>

00:06:09.149 --> 00:06:09.159 align:start position:0%
higher-order functions formalities
 

00:06:09.159 --> 00:06:11.100 align:start position:0%
higher-order functions formalities
extremely<00:06:09.610><c> fast</c><00:06:09.820><c> right</c><00:06:10.090><c> now</c><00:06:10.120><c> but</c><00:06:10.930><c> there's</c>

00:06:11.100 --> 00:06:11.110 align:start position:0%
extremely fast right now but there's
 

00:06:11.110 --> 00:06:12.990 align:start position:0%
extremely fast right now but there's
still<00:06:11.260><c> substantial</c><00:06:11.830><c> overhead</c><00:06:12.280><c> which</c><00:06:12.820><c> makes</c>

00:06:12.990 --> 00:06:13.000 align:start position:0%
still substantial overhead which makes
 

00:06:13.000 --> 00:06:15.330 align:start position:0%
still substantial overhead which makes
us<00:06:13.120><c> only</c><00:06:13.270><c> moderately</c><00:06:13.930><c> fast</c><00:06:14.110><c> on</c><00:06:14.380><c> average</c><00:06:14.800><c> at</c>

00:06:15.330 --> 00:06:15.340 align:start position:0%
us only moderately fast on average at
 

00:06:15.340 --> 00:06:17.189 align:start position:0%
us only moderately fast on average at
the<00:06:15.490><c> moment</c><00:06:15.849><c> we</c><00:06:16.510><c> think</c><00:06:16.690><c> in</c><00:06:16.780><c> future</c><00:06:16.900><c> our</c>

00:06:17.189 --> 00:06:17.199 align:start position:0%
the moment we think in future our
 

00:06:17.199 --> 00:06:18.540 align:start position:0%
the moment we think in future our
interaction<00:06:17.710><c> that</c><00:06:17.830><c> model</c><00:06:18.099><c> will</c><00:06:18.190><c> pay</c><00:06:18.310><c> a</c><00:06:18.340><c> lot</c><00:06:18.520><c> of</c>

00:06:18.540 --> 00:06:18.550 align:start position:0%
interaction that model will pay a lot of
 

00:06:18.550 --> 00:06:20.310 align:start position:0%
interaction that model will pay a lot of
dividends<00:06:19.030><c> here</c><00:06:19.210><c> performance</c><00:06:19.990><c> is</c><00:06:20.080><c> really</c>

00:06:20.310 --> 00:06:20.320 align:start position:0%
dividends here performance is really
 

00:06:20.320 --> 00:06:22.350 align:start position:0%
dividends here performance is really
critical<00:06:20.889><c> to</c><00:06:21.010><c> us</c><00:06:21.159><c> for</c><00:06:21.909><c> getting</c><00:06:22.000><c> people</c><00:06:22.180><c> to</c>

00:06:22.350 --> 00:06:22.360 align:start position:0%
critical to us for getting people to
 

00:06:22.360 --> 00:06:24.270 align:start position:0%
critical to us for getting people to
adopt<00:06:22.539><c> formality</c><00:06:23.110><c> and</c><00:06:23.260><c> using</c><00:06:23.590><c> it</c><00:06:23.680><c> to</c><00:06:23.710><c> build</c>

00:06:24.270 --> 00:06:24.280 align:start position:0%
adopt formality and using it to build
 

00:06:24.280 --> 00:06:27.390 align:start position:0%
adopt formality and using it to build
lots<00:06:24.430><c> of</c><00:06:24.639><c> great</c><00:06:25.240><c> software</c><00:06:26.039><c> one</c><00:06:27.039><c> interesting</c>

00:06:27.390 --> 00:06:27.400 align:start position:0%
lots of great software one interesting
 

00:06:27.400 --> 00:06:28.860 align:start position:0%
lots of great software one interesting
thing<00:06:27.520><c> about</c><00:06:27.550><c> these</c><00:06:27.820><c> benchmarks</c><00:06:28.270><c> is</c><00:06:28.389><c> that</c><00:06:28.690><c> if</c>

00:06:28.860 --> 00:06:28.870 align:start position:0%
thing about these benchmarks is that if
 

00:06:28.870 --> 00:06:31.320 align:start position:0%
thing about these benchmarks is that if
instead<00:06:29.830><c> I</c><00:06:30.039><c> call</c><00:06:30.250><c> the</c><00:06:30.370><c> function</c><00:06:30.550><c> not</c><00:06:30.940><c> ten</c><00:06:31.240><c> to</c>

00:06:31.320 --> 00:06:31.330 align:start position:0%
instead I call the function not ten to
 

00:06:31.330 --> 00:06:33.240 align:start position:0%
instead I call the function not ten to
the<00:06:31.360><c> hundred</c><00:06:31.690><c> times</c><00:06:31.900><c> but</c><00:06:32.139><c> ten</c><00:06:32.380><c> to</c><00:06:32.710><c> the</c><00:06:32.830><c> hundred</c>

00:06:33.240 --> 00:06:33.250 align:start position:0%
the hundred times but ten to the hundred
 

00:06:33.250 --> 00:06:35.219 align:start position:0%
the hundred times but ten to the hundred
thousand<00:06:33.669><c> it</c><00:06:33.880><c> still</c><00:06:34.270><c> only</c><00:06:34.449><c> takes</c><00:06:34.840><c> like</c><00:06:35.020><c> 12</c>

00:06:35.219 --> 00:06:35.229 align:start position:0%
thousand it still only takes like 12
 

00:06:35.229 --> 00:06:37.800 align:start position:0%
thousand it still only takes like 12
seconds<00:06:35.560><c> which</c><00:06:35.949><c> is</c><00:06:36.099><c> you</c><00:06:36.699><c> know</c><00:06:36.789><c> way</c><00:06:37.570><c> better</c>

00:06:37.800 --> 00:06:37.810 align:start position:0%
seconds which is you know way better
 

00:06:37.810 --> 00:06:39.450 align:start position:0%
seconds which is you know way better
than<00:06:38.139><c> I</c><00:06:38.380><c> think</c><00:06:38.590><c> pretty</c><00:06:39.010><c> much</c><00:06:39.130><c> any</c><00:06:39.280><c> other</c>

00:06:39.450 --> 00:06:39.460 align:start position:0%
than I think pretty much any other
 

00:06:39.460 --> 00:06:40.680 align:start position:0%
than I think pretty much any other
language<00:06:39.729><c> that</c><00:06:39.849><c> I've</c><00:06:39.940><c> used</c><00:06:40.120><c> unless</c><00:06:40.419><c> you</c><00:06:40.570><c> do</c>

00:06:40.680 --> 00:06:40.690 align:start position:0%
language that I've used unless you do
 

00:06:40.690 --> 00:06:42.580 align:start position:0%
language that I've used unless you do
like<00:06:40.840><c> crazy</c><00:06:41.080><c> optimizations</c>

00:06:42.580 --> 00:06:42.590 align:start position:0%
like crazy optimizations
 

00:06:42.590 --> 00:06:46.490 align:start position:0%
like crazy optimizations
here's<00:06:43.590><c> why</c><00:06:43.710><c> proofs</c><00:06:43.950><c> matter</c><00:06:45.140><c> here's</c><00:06:46.140><c> a</c><00:06:46.230><c> sample</c>

00:06:46.490 --> 00:06:46.500 align:start position:0%
here's why proofs matter here's a sample
 

00:06:46.500 --> 00:06:47.900 align:start position:0%
here's why proofs matter here's a sample
of<00:06:46.530><c> some</c><00:06:46.680><c> costly</c><00:06:47.070><c> issues</c><00:06:47.490><c> that</c><00:06:47.700><c> have</c><00:06:47.790><c> happened</c>

00:06:47.900 --> 00:06:47.910 align:start position:0%
of some costly issues that have happened
 

00:06:47.910 --> 00:06:49.070 align:start position:0%
of some costly issues that have happened
at<00:06:48.120><c> different</c><00:06:48.420><c> parts</c><00:06:48.630><c> of</c><00:06:48.690><c> the</c><00:06:48.810><c> stack</c><00:06:49.050><c> that</c>

00:06:49.070 --> 00:06:49.080 align:start position:0%
at different parts of the stack that
 

00:06:49.080 --> 00:06:50.750 align:start position:0%
at different parts of the stack that
perhaps<00:06:49.440><c> could</c><00:06:49.770><c> have</c><00:06:49.830><c> benefited</c><00:06:50.370><c> from</c><00:06:50.400><c> proofs</c>

00:06:50.750 --> 00:06:50.760 align:start position:0%
perhaps could have benefited from proofs
 

00:06:50.760 --> 00:06:53.120 align:start position:0%
perhaps could have benefited from proofs
and<00:06:50.910><c> type</c><00:06:51.060><c> safety</c><00:06:51.350><c> heartbleed</c><00:06:52.350><c> that's</c><00:06:52.890><c> just</c>

00:06:53.120 --> 00:06:53.130 align:start position:0%
and type safety heartbleed that's just
 

00:06:53.130 --> 00:06:55.970 align:start position:0%
and type safety heartbleed that's just
an<00:06:53.250><c> out</c><00:06:53.400><c> of</c><00:06:53.430><c> bounds</c><00:06:53.670><c> indexing</c><00:06:54.360><c> error</c><00:06:54.980><c> now</c>

00:06:55.970 --> 00:06:55.980 align:start position:0%
an out of bounds indexing error now
 

00:06:55.980 --> 00:06:57.950 align:start position:0%
an out of bounds indexing error now
proofs<00:06:56.640><c> aren't</c><00:06:56.850><c> a</c><00:06:56.880><c> silver</c><00:06:57.210><c> bullet</c><00:06:57.420><c> because</c>

00:06:57.950 --> 00:06:57.960 align:start position:0%
proofs aren't a silver bullet because
 

00:06:57.960 --> 00:06:59.090 align:start position:0%
proofs aren't a silver bullet because
all<00:06:58.080><c> these</c><00:06:58.170><c> issues</c><00:06:58.440><c> are</c><00:06:58.590><c> really</c><00:06:58.710><c> complicated</c>

00:06:59.090 --> 00:06:59.100 align:start position:0%
all these issues are really complicated
 

00:06:59.100 --> 00:07:01.910 align:start position:0%
all these issues are really complicated
but<00:06:59.850><c> if</c><00:07:00.030><c> proofs</c><00:07:00.540><c> can</c><00:07:00.690><c> reduce</c><00:07:01.230><c> the</c><00:07:01.410><c> severity</c><00:07:01.770><c> or</c>

00:07:01.910 --> 00:07:01.920 align:start position:0%
but if proofs can reduce the severity or
 

00:07:01.920 --> 00:07:03.590 align:start position:0%
but if proofs can reduce the severity or
incidence<00:07:02.430><c> of</c><00:07:02.520><c> these</c><00:07:02.670><c> kinds</c><00:07:03.030><c> of</c><00:07:03.090><c> errors</c><00:07:03.420><c> even</c>

00:07:03.590 --> 00:07:03.600 align:start position:0%
incidence of these kinds of errors even
 

00:07:03.600 --> 00:07:05.420 align:start position:0%
incidence of these kinds of errors even
just<00:07:03.900><c> a</c><00:07:03.960><c> little</c><00:07:04.170><c> bit</c><00:07:04.260><c> at</c><00:07:04.350><c> the</c><00:07:04.440><c> margin</c><00:07:04.800><c> I</c><00:07:04.950><c> think</c>

00:07:05.420 --> 00:07:05.430 align:start position:0%
just a little bit at the margin I think
 

00:07:05.430 --> 00:07:08.390 align:start position:0%
just a little bit at the margin I think
it's<00:07:05.550><c> worth</c><00:07:05.760><c> exploring</c><00:07:06.120><c> and</c><00:07:07.010><c> in</c><00:07:08.010><c> black</c><00:07:08.190><c> Shang</c>

00:07:08.390 --> 00:07:08.400 align:start position:0%
it's worth exploring and in black Shang
 

00:07:08.400 --> 00:07:09.680 align:start position:0%
it's worth exploring and in black Shang
I<00:07:08.490><c> think</c><00:07:08.670><c> it's</c><00:07:08.760><c> especially</c><00:07:08.970><c> especially</c>

00:07:09.680 --> 00:07:09.690 align:start position:0%
I think it's especially especially
 

00:07:09.690 --> 00:07:11.570 align:start position:0%
I think it's especially especially
relevant<00:07:09.960><c> because</c><00:07:10.590><c> the</c><00:07:10.710><c> ratio</c><00:07:10.860><c> between</c><00:07:11.160><c> code</c>

00:07:11.570 --> 00:07:11.580 align:start position:0%
relevant because the ratio between code
 

00:07:11.580 --> 00:07:14.600 align:start position:0%
relevant because the ratio between code
complexity<00:07:12.060><c> and</c><00:07:12.270><c> code</c><00:07:12.420><c> value</c><00:07:12.900><c> is</c><00:07:13.530><c> so</c><00:07:14.070><c> extreme</c>

00:07:14.600 --> 00:07:14.610 align:start position:0%
complexity and code value is so extreme
 

00:07:14.610 --> 00:07:17.240 align:start position:0%
complexity and code value is so extreme
here<00:07:15.360><c> I</c><00:07:15.390><c> just</c><00:07:15.750><c> counted</c><00:07:16.410><c> the</c><00:07:16.440><c> lines</c><00:07:16.650><c> in</c><00:07:17.010><c> you</c>

00:07:17.240 --> 00:07:17.250 align:start position:0%
here I just counted the lines in you
 

00:07:17.250 --> 00:07:20.780 align:start position:0%
here I just counted the lines in you
know<00:07:17.340><c> some</c><00:07:17.960><c> popular</c><00:07:18.960><c> projects</c><00:07:19.950><c> you</c><00:07:20.070><c> know</c><00:07:20.190><c> ba</c>

00:07:20.780 --> 00:07:20.790 align:start position:0%
know some popular projects you know ba
 

00:07:20.790 --> 00:07:24.170 align:start position:0%
know some popular projects you know ba
tu<00:07:21.120><c> SDC</c><00:07:21.870><c> and</c><00:07:22.080><c> you</c><00:07:22.740><c> know</c><00:07:22.830><c> a</c><00:07:23.280><c> lot</c><00:07:23.670><c> of</c><00:07:23.700><c> projects</c>

00:07:24.170 --> 00:07:24.180 align:start position:0%
tu SDC and you know a lot of projects
 

00:07:24.180 --> 00:07:25.910 align:start position:0%
tu SDC and you know a lot of projects
are<00:07:24.330><c> running</c><00:07:24.930><c> at</c><00:07:25.020><c> about</c><00:07:25.110><c> a</c><00:07:25.230><c> million</c><00:07:25.560><c> line</c><00:07:25.890><c> a</c>

00:07:25.910 --> 00:07:25.920 align:start position:0%
are running at about a million line a
 

00:07:25.920 --> 00:07:27.860 align:start position:0%
are running at about a million line a
million<00:07:26.400><c> dollars</c><00:07:26.760><c> of</c><00:07:26.970><c> capital</c><00:07:27.150><c> per</c><00:07:27.510><c> lines</c><00:07:27.690><c> of</c>

00:07:27.860 --> 00:07:27.870 align:start position:0%
million dollars of capital per lines of
 

00:07:27.870 --> 00:07:29.660 align:start position:0%
million dollars of capital per lines of
code<00:07:28.050><c> so</c><00:07:28.560><c> I</c><00:07:28.590><c> think</c><00:07:28.740><c> it's</c><00:07:28.920><c> really</c><00:07:29.160><c> important</c>

00:07:29.660 --> 00:07:29.670 align:start position:0%
code so I think it's really important
 

00:07:29.670 --> 00:07:31.370 align:start position:0%
code so I think it's really important
that<00:07:30.030><c> if</c><00:07:30.240><c> you're</c><00:07:30.390><c> writing</c><00:07:30.750><c> projects</c><00:07:31.230><c> like</c>

00:07:31.370 --> 00:07:31.380 align:start position:0%
that if you're writing projects like
 

00:07:31.380 --> 00:07:32.960 align:start position:0%
that if you're writing projects like
that<00:07:31.560><c> it's</c><00:07:31.800><c> you</c><00:07:32.190><c> should</c><00:07:32.370><c> put</c><00:07:32.520><c> a</c><00:07:32.550><c> little</c><00:07:32.700><c> extra</c>

00:07:32.960 --> 00:07:32.970 align:start position:0%
that it's you should put a little extra
 

00:07:32.970 --> 00:07:34.460 align:start position:0%
that it's you should put a little extra
effort<00:07:33.330><c> in</c><00:07:33.480><c> trying</c><00:07:33.780><c> to</c><00:07:33.930><c> make</c><00:07:34.050><c> sure</c><00:07:34.170><c> that</c><00:07:34.320><c> the</c>

00:07:34.460 --> 00:07:34.470 align:start position:0%
effort in trying to make sure that the
 

00:07:34.470 --> 00:07:35.930 align:start position:0%
effort in trying to make sure that the
lines<00:07:34.620><c> of</c><00:07:34.770><c> code</c><00:07:34.920><c> are</c><00:07:35.100><c> actually</c><00:07:35.640><c> the</c><00:07:35.730><c> correct</c>

00:07:35.930 --> 00:07:35.940 align:start position:0%
lines of code are actually the correct
 

00:07:35.940 --> 00:07:40.010 align:start position:0%
lines of code are actually the correct
lines<00:07:36.210><c> of</c><00:07:36.360><c> code</c><00:07:37.970><c> one</c><00:07:38.970><c> criticism</c><00:07:39.360><c> of</c><00:07:39.630><c> proofs</c><00:07:39.870><c> is</c>

00:07:40.010 --> 00:07:40.020 align:start position:0%
lines of code one criticism of proofs is
 

00:07:40.020 --> 00:07:41.360 align:start position:0%
lines of code one criticism of proofs is
that<00:07:40.230><c> they</c><00:07:40.350><c> pass</c><00:07:40.530><c> responsibility</c><00:07:41.220><c> for</c>

00:07:41.360 --> 00:07:41.370 align:start position:0%
that they pass responsibility for
 

00:07:41.370 --> 00:07:43.250 align:start position:0%
that they pass responsibility for
correctness<00:07:41.670><c> to</c><00:07:41.910><c> the</c><00:07:42.000><c> specification</c><00:07:42.720><c> rather</c>

00:07:43.250 --> 00:07:43.260 align:start position:0%
correctness to the specification rather
 

00:07:43.260 --> 00:07:44.570 align:start position:0%
correctness to the specification rather
than<00:07:43.500><c> the</c><00:07:43.590><c> implementation</c><00:07:44.160><c> and</c><00:07:44.280><c> you</c><00:07:44.370><c> still</c>

00:07:44.570 --> 00:07:44.580 align:start position:0%
than the implementation and you still
 

00:07:44.580 --> 00:07:45.950 align:start position:0%
than the implementation and you still
have<00:07:44.700><c> to</c><00:07:44.790><c> audit</c><00:07:44.970><c> it</c><00:07:45.180><c> and</c><00:07:45.330><c> that's</c><00:07:45.660><c> completely</c>

00:07:45.950 --> 00:07:45.960 align:start position:0%
have to audit it and that's completely
 

00:07:45.960 --> 00:07:47.660 align:start position:0%
have to audit it and that's completely
true<00:07:46.320><c> like</c><00:07:46.560><c> it</c><00:07:46.680><c> doesn't</c><00:07:46.950><c> this</c><00:07:47.130><c> proofs</c><00:07:47.490><c> don't</c>

00:07:47.660 --> 00:07:47.670 align:start position:0%
true like it doesn't this proofs don't
 

00:07:47.670 --> 00:07:49.460 align:start position:0%
true like it doesn't this proofs don't
solve<00:07:47.880><c> having</c><00:07:48.240><c> to</c><00:07:48.330><c> actually</c><00:07:48.480><c> think</c><00:07:49.260><c> about</c>

00:07:49.460 --> 00:07:49.470 align:start position:0%
solve having to actually think about
 

00:07:49.470 --> 00:07:51.080 align:start position:0%
solve having to actually think about
your<00:07:49.590><c> code</c><00:07:49.740><c> and</c><00:07:49.920><c> reason</c><00:07:50.220><c> reason</c><00:07:50.760><c> that</c><00:07:51.000><c> is</c>

00:07:51.080 --> 00:07:51.090 align:start position:0%
your code and reason reason that is
 

00:07:51.090 --> 00:07:53.300 align:start position:0%
your code and reason reason that is
correct<00:07:51.450><c> and</c><00:07:52.350><c> if</c><00:07:52.470><c> you're</c><00:07:52.590><c> type</c><00:07:52.770><c> spec</c><00:07:52.980><c> is</c><00:07:53.100><c> bad</c>

00:07:53.300 --> 00:07:53.310 align:start position:0%
correct and if you're type spec is bad
 

00:07:53.310 --> 00:07:55.550 align:start position:0%
correct and if you're type spec is bad
then<00:07:53.580><c> you'd</c><00:07:53.730><c> proofs</c><00:07:53.970><c> don't</c><00:07:54.240><c> help</c><00:07:54.420><c> you</c><00:07:54.560><c> but</c>

00:07:55.550 --> 00:07:55.560 align:start position:0%
then you'd proofs don't help you but
 

00:07:55.560 --> 00:07:57.980 align:start position:0%
then you'd proofs don't help you but
type<00:07:56.220><c> specifications</c><00:07:56.970><c> can</c><00:07:57.150><c> be</c><00:07:57.270><c> much</c><00:07:57.630><c> simpler</c>

00:07:57.980 --> 00:07:57.990 align:start position:0%
type specifications can be much simpler
 

00:07:57.990 --> 00:07:59.780 align:start position:0%
type specifications can be much simpler
than<00:07:58.140><c> the</c><00:07:58.260><c> code</c><00:07:58.410><c> they're</c><00:07:58.560><c> typing</c><00:07:58.920><c> and</c><00:07:59.640><c> at</c>

00:07:59.780 --> 00:07:59.790 align:start position:0%
than the code they're typing and at
 

00:07:59.790 --> 00:08:01.250 align:start position:0%
than the code they're typing and at
worst<00:08:00.030><c> act</c><00:08:00.300><c> like</c><00:08:00.450><c> a</c><00:08:00.480><c> compiler</c><00:08:01.080><c> check</c>

00:08:01.250 --> 00:08:01.260 align:start position:0%
worst act like a compiler check
 

00:08:01.260 --> 00:08:03.020 align:start position:0%
worst act like a compiler check
documentation<00:08:01.950><c> here's</c><00:08:02.520><c> a</c><00:08:02.580><c> little</c><00:08:02.820><c> snippet</c>

00:08:03.020 --> 00:08:03.030 align:start position:0%
documentation here's a little snippet
 

00:08:03.030 --> 00:08:08.120 align:start position:0%
documentation here's a little snippet
from<00:08:03.780><c> our</c><00:08:04.080><c> er</c><00:08:04.800><c> C</c><00:08:04.950><c> 20</c><00:08:05.300><c> implementation</c><00:08:06.300><c> and</c><00:08:07.130><c> you</c>

00:08:08.120 --> 00:08:08.130 align:start position:0%
from our er C 20 implementation and you
 

00:08:08.130 --> 00:08:09.680 align:start position:0%
from our er C 20 implementation and you
can<00:08:08.280><c> see</c><00:08:08.430><c> that</c><00:08:08.640><c> like</c><00:08:08.790><c> if</c><00:08:09.090><c> we</c><00:08:09.330><c> that</c><00:08:09.540><c> we</c><00:08:09.660><c> have</c>

00:08:09.680 --> 00:08:09.690 align:start position:0%
can see that like if we that we have
 

00:08:09.690 --> 00:08:11.330 align:start position:0%
can see that like if we that we have
this<00:08:10.020><c> type</c><00:08:10.260><c> specification</c><00:08:10.920><c> that</c><00:08:11.040><c> says</c><00:08:11.160><c> I</c><00:08:11.220><c> have</c>

00:08:11.330 --> 00:08:11.340 align:start position:0%
this type specification that says I have
 

00:08:11.340 --> 00:08:13.220 align:start position:0%
this type specification that says I have
a<00:08:11.400><c> transfer</c><00:08:11.790><c> function</c><00:08:11.820><c> I</c><00:08:12.330><c> have</c><00:08:12.540><c> the</c><00:08:12.810><c> approvals</c>

00:08:13.220 --> 00:08:13.230 align:start position:0%
a transfer function I have the approvals
 

00:08:13.230 --> 00:08:14.630 align:start position:0%
a transfer function I have the approvals
have<00:08:13.380><c> to</c><00:08:13.470><c> be</c><00:08:13.560><c> in</c><00:08:13.650><c> an</c><00:08:13.770><c> old</c><00:08:13.920><c> state</c><00:08:14.190><c> that</c><00:08:14.340><c> has</c><00:08:14.520><c> to</c>

00:08:14.630 --> 00:08:14.640 align:start position:0%
have to be in an old state that has to
 

00:08:14.640 --> 00:08:16.820 align:start position:0%
have to be in an old state that has to
be<00:08:14.730><c> removed</c><00:08:14.940><c> from</c><00:08:15.090><c> a</c><00:08:15.210><c> new</c><00:08:15.330><c> state</c><00:08:15.540><c> and</c><00:08:15.750><c> it</c><00:08:16.680><c> has</c>

00:08:16.820 --> 00:08:16.830 align:start position:0%
be removed from a new state and it has
 

00:08:16.830 --> 00:08:17.840 align:start position:0%
be removed from a new state and it has
to<00:08:16.950><c> obey</c><00:08:17.040><c> a</c><00:08:17.160><c> double</c><00:08:17.460><c> entry</c><00:08:17.610><c> bookkeeping</c>

00:08:17.840 --> 00:08:17.850 align:start position:0%
to obey a double entry bookkeeping
 

00:08:17.850 --> 00:08:19.730 align:start position:0%
to obey a double entry bookkeeping
environment<00:08:18.570><c> you</c><00:08:18.960><c> don't</c><00:08:19.110><c> even</c><00:08:19.230><c> need</c><00:08:19.440><c> to</c><00:08:19.500><c> see</c>

00:08:19.730 --> 00:08:19.740 align:start position:0%
environment you don't even need to see
 

00:08:19.740 --> 00:08:21.140 align:start position:0%
environment you don't even need to see
the<00:08:19.860><c> implementation</c><00:08:20.070><c> to</c><00:08:20.610><c> know</c><00:08:20.760><c> that</c><00:08:20.970><c> if</c><00:08:21.060><c> it</c>

00:08:21.140 --> 00:08:21.150 align:start position:0%
the implementation to know that if it
 

00:08:21.150 --> 00:08:22.670 align:start position:0%
the implementation to know that if it
type<00:08:21.360><c> checks</c><00:08:21.660><c> those</c><00:08:21.840><c> properties</c><00:08:22.410><c> that</c><00:08:22.530><c> it's</c>

00:08:22.670 --> 00:08:22.680 align:start position:0%
type checks those properties that it's
 

00:08:22.680 --> 00:08:24.860 align:start position:0%
type checks those properties that it's
going<00:08:22.890><c> to</c><00:08:23.010><c> long</c><00:08:23.820><c> as</c><00:08:23.940><c> the</c><00:08:24.030><c> compilers</c><00:08:24.480><c> valid</c>

00:08:24.860 --> 00:08:24.870 align:start position:0%
going to long as the compilers valid
 

00:08:24.870 --> 00:08:26.750 align:start position:0%
going to long as the compilers valid
that<00:08:25.290><c> it's</c><00:08:25.440><c> going</c><00:08:25.620><c> to</c><00:08:25.710><c> be</c><00:08:25.860><c> safe</c><00:08:26.130><c> according</c><00:08:26.670><c> to</c>

00:08:26.750 --> 00:08:26.760 align:start position:0%
that it's going to be safe according to
 

00:08:26.760 --> 00:08:29.330 align:start position:0%
that it's going to be safe according to
those<00:08:26.850><c> properties</c><00:08:27.710><c> the</c><00:08:28.710><c> vision</c><00:08:29.010><c> is</c><00:08:29.130><c> to</c><00:08:29.250><c> have</c>

00:08:29.330 --> 00:08:29.340 align:start position:0%
those properties the vision is to have
 

00:08:29.340 --> 00:08:30.740 align:start position:0%
those properties the vision is to have
formality<00:08:29.820><c> be</c><00:08:29.940><c> a</c><00:08:29.970><c> language</c><00:08:30.180><c> that</c><00:08:30.480><c> can</c><00:08:30.540><c> add</c>

00:08:30.740 --> 00:08:30.750 align:start position:0%
formality be a language that can add
 

00:08:30.750 --> 00:08:32.810 align:start position:0%
formality be a language that can add
type<00:08:31.050><c> safety</c><00:08:31.350><c> at</c><00:08:31.680><c> every</c><00:08:32.310><c> layer</c><00:08:32.430><c> of</c><00:08:32.490><c> the</c><00:08:32.760><c> stack</c>

00:08:32.810 --> 00:08:32.820 align:start position:0%
type safety at every layer of the stack
 

00:08:32.820 --> 00:08:34.640 align:start position:0%
type safety at every layer of the stack
having<00:08:33.719><c> the</c><00:08:33.810><c> same</c><00:08:33.960><c> language</c><00:08:34.260><c> every</c><00:08:34.469><c> matter</c>

00:08:34.640 --> 00:08:34.650 align:start position:0%
having the same language every matter
 

00:08:34.650 --> 00:08:36.110 align:start position:0%
having the same language every matter
means<00:08:35.130><c> that</c><00:08:35.250><c> you</c><00:08:35.310><c> can</c><00:08:35.460><c> use</c><00:08:35.580><c> the</c><00:08:35.700><c> same</c><00:08:35.849><c> types</c>

00:08:36.110 --> 00:08:36.120 align:start position:0%
means that you can use the same types
 

00:08:36.120 --> 00:08:37.880 align:start position:0%
means that you can use the same types
everywhere<00:08:36.539><c> with</c><00:08:36.960><c> minimal</c><00:08:37.320><c> friction</c><00:08:37.440><c> and</c>

00:08:37.880 --> 00:08:37.890 align:start position:0%
everywhere with minimal friction and
 

00:08:37.890 --> 00:08:39.409 align:start position:0%
everywhere with minimal friction and
this<00:08:38.370><c> is</c><00:08:38.430><c> what's</c><00:08:38.550><c> awesome</c><00:08:38.700><c> about</c><00:08:38.910><c> having</c><00:08:39.360><c> a</c>

00:08:39.409 --> 00:08:39.419 align:start position:0%
this is what's awesome about having a
 

00:08:39.419 --> 00:08:41.690 align:start position:0%
this is what's awesome about having a
400<00:08:39.960><c> line</c><00:08:40.140><c> language</c><00:08:40.620><c> implementation</c><00:08:41.250><c> we</c><00:08:41.669><c> can</c>

00:08:41.690 --> 00:08:41.700 align:start position:0%
400 line language implementation we can
 

00:08:41.700 --> 00:08:42.860 align:start position:0%
400 line language implementation we can
have<00:08:41.910><c> the</c><00:08:42.000><c> same</c><00:08:42.150><c> language</c><00:08:42.419><c> infrastructure</c>

00:08:42.860 --> 00:08:42.870 align:start position:0%
have the same language infrastructure
 

00:08:42.870 --> 00:08:44.780 align:start position:0%
have the same language infrastructure
running<00:08:43.229><c> inside</c><00:08:43.440><c> a</c><00:08:43.500><c> web</c><00:08:43.710><c> app</c><00:08:43.890><c> smart</c><00:08:44.340><c> contract</c>

00:08:44.780 --> 00:08:44.790 align:start position:0%
running inside a web app smart contract
 

00:08:44.790 --> 00:08:49.300 align:start position:0%
running inside a web app smart contract
server<00:08:45.380><c> editor</c><00:08:46.380><c> plug-in</c><00:08:46.740><c> or</c><00:08:46.920><c> our</c><00:08:47.340><c> test</c><00:08:47.550><c> suite</c>

00:08:49.300 --> 00:08:49.310 align:start position:0%
server editor plug-in or our test suite
 

00:08:49.310 --> 00:08:51.620 align:start position:0%
server editor plug-in or our test suite
our<00:08:50.310><c> next</c><00:08:50.550><c> big</c><00:08:50.700><c> priority</c><00:08:51.270><c> now</c><00:08:51.390><c> that</c><00:08:51.420><c> the</c>

00:08:51.620 --> 00:08:51.630 align:start position:0%
our next big priority now that the
 

00:08:51.630 --> 00:08:53.329 align:start position:0%
our next big priority now that the
language<00:08:51.960><c> is</c><00:08:52.080><c> pretty</c><00:08:52.200><c> stable</c><00:08:52.500><c> is</c><00:08:52.800><c> to</c><00:08:53.160><c> write</c>

00:08:53.329 --> 00:08:53.339 align:start position:0%
language is pretty stable is to write
 

00:08:53.339 --> 00:08:54.740 align:start position:0%
language is pretty stable is to write
the<00:08:53.460><c> compilers</c><00:08:54.000><c> that</c><00:08:54.150><c> will</c><00:08:54.240><c> let</c><00:08:54.360><c> us</c><00:08:54.390><c> deploy</c>

00:08:54.740 --> 00:08:54.750 align:start position:0%
the compilers that will let us deploy
 

00:08:54.750 --> 00:08:55.550 align:start position:0%
the compilers that will let us deploy
formality<00:08:55.290><c> smart</c>

00:08:55.550 --> 00:08:55.560 align:start position:0%
formality smart
 

00:08:55.560 --> 00:08:57.500 align:start position:0%
formality smart
contracts<00:08:55.920><c> and</c><00:08:56.190><c> to</c><00:08:56.400><c> continue</c><00:08:56.730><c> maturing</c><00:08:57.420><c> the</c>

00:08:57.500 --> 00:08:57.510 align:start position:0%
contracts and to continue maturing the
 

00:08:57.510 --> 00:08:59.330 align:start position:0%
contracts and to continue maturing the
library's<00:08:57.900><c> tools</c><00:08:58.170><c> and</c><00:08:58.380><c> Docs</c><00:08:58.560><c> to</c><00:08:59.010><c> make</c><00:08:59.160><c> that</c><00:08:59.310><c> a</c>

00:08:59.330 --> 00:08:59.340 align:start position:0%
library's tools and Docs to make that a
 

00:08:59.340 --> 00:09:01.910 align:start position:0%
library's tools and Docs to make that a
really<00:08:59.670><c> great</c><00:08:59.850><c> user</c><00:09:00.060><c> experience</c><00:09:00.630><c> after</c><00:09:01.110><c> that</c>

00:09:01.910 --> 00:09:01.920 align:start position:0%
really great user experience after that
 

00:09:01.920 --> 00:09:03.590 align:start position:0%
really great user experience after that
implementing<00:09:02.430><c> formality</c><00:09:02.880><c> in</c><00:09:02.970><c> itself</c><00:09:03.270><c> will</c>

00:09:03.590 --> 00:09:03.600 align:start position:0%
implementing formality in itself will
 

00:09:03.600 --> 00:09:05.060 align:start position:0%
implementing formality in itself will
improve<00:09:03.840><c> portability</c><00:09:04.380><c> even</c><00:09:04.590><c> further</c><00:09:04.830><c> and</c>

00:09:05.060 --> 00:09:05.070 align:start position:0%
improve portability even further and
 

00:09:05.070 --> 00:09:06.380 align:start position:0%
improve portability even further and
we're<00:09:05.220><c> gonna</c><00:09:05.310><c> see</c><00:09:05.520><c> how</c><00:09:05.610><c> fast</c><00:09:05.820><c> we</c><00:09:05.940><c> can</c><00:09:06.029><c> push</c><00:09:06.240><c> the</c>

00:09:06.380 --> 00:09:06.390 align:start position:0%
we're gonna see how fast we can push the
 

00:09:06.390 --> 00:09:09.350 align:start position:0%
we're gonna see how fast we can push the
existing<00:09:06.750><c> C</c><00:09:06.900><c> implementation</c><00:09:08.240><c> the</c><00:09:09.240><c> two</c>

00:09:09.350 --> 00:09:09.360 align:start position:0%
existing C implementation the two
 

00:09:09.360 --> 00:09:10.519 align:start position:0%
existing C implementation the two
projects<00:09:09.690><c> after</c><00:09:09.779><c> that</c><00:09:09.990><c> are</c><00:09:10.110><c> going</c><00:09:10.200><c> to</c><00:09:10.290><c> be</c><00:09:10.380><c> our</c>

00:09:10.519 --> 00:09:10.529 align:start position:0%
projects after that are going to be our
 

00:09:10.529 --> 00:09:11.960 align:start position:0%
projects after that are going to be our
package<00:09:10.830><c> management</c><00:09:11.130><c> infrastructure</c><00:09:11.670><c> and</c>

00:09:11.960 --> 00:09:11.970 align:start position:0%
package management infrastructure and
 

00:09:11.970 --> 00:09:13.400 align:start position:0%
package management infrastructure and
putting<00:09:12.210><c> the</c><00:09:12.270><c> formality</c><00:09:12.660><c> type</c><00:09:12.839><c> checker</c><00:09:13.080><c> on</c><00:09:13.200><c> an</c>

00:09:13.400 --> 00:09:13.410 align:start position:0%
putting the formality type checker on an
 

00:09:13.410 --> 00:09:16.400 align:start position:0%
putting the formality type checker on an
aetherium<00:09:13.830><c> contract</c><00:09:14.570><c> that</c><00:09:15.570><c> enables</c><00:09:16.230><c> us</c><00:09:16.350><c> to</c>

00:09:16.400 --> 00:09:16.410 align:start position:0%
aetherium contract that enables us to
 

00:09:16.410 --> 00:09:18.170 align:start position:0%
aetherium contract that enables us to
build<00:09:16.589><c> a</c><00:09:16.680><c> completely</c><00:09:17.070><c> trustless</c><00:09:17.670><c> marketplace</c>

00:09:18.170 --> 00:09:18.180 align:start position:0%
build a completely trustless marketplace
 

00:09:18.180 --> 00:09:20.030 align:start position:0%
build a completely trustless marketplace
for<00:09:18.390><c> code</c><00:09:18.570><c> and</c><00:09:18.720><c> proofs</c><00:09:18.960><c> you</c><00:09:19.589><c> can</c><00:09:19.710><c> submit</c><00:09:19.980><c> a</c>

00:09:20.030 --> 00:09:20.040 align:start position:0%
for code and proofs you can submit a
 

00:09:20.040 --> 00:09:21.829 align:start position:0%
for code and proofs you can submit a
formality<00:09:20.400><c> type</c><00:09:20.730><c> to</c><00:09:20.910><c> a</c><00:09:20.940><c> contract</c><00:09:21.450><c> along</c><00:09:21.660><c> with</c>

00:09:21.829 --> 00:09:21.839 align:start position:0%
formality type to a contract along with
 

00:09:21.839 --> 00:09:23.030 align:start position:0%
formality type to a contract along with
a<00:09:21.870><c> bounty</c><00:09:22.230><c> for</c><00:09:22.380><c> the</c><00:09:22.440><c> first</c><00:09:22.680><c> valid</c>

00:09:23.030 --> 00:09:23.040 align:start position:0%
a bounty for the first valid
 

00:09:23.040 --> 00:09:24.650 align:start position:0%
a bounty for the first valid
implementation<00:09:23.580><c> of</c><00:09:23.670><c> that</c><00:09:23.700><c> type</c><00:09:23.970><c> and</c><00:09:24.210><c> then</c>

00:09:24.650 --> 00:09:24.660 align:start position:0%
implementation of that type and then
 

00:09:24.660 --> 00:09:25.940 align:start position:0%
implementation of that type and then
anyone<00:09:24.990><c> in</c><00:09:25.080><c> the</c><00:09:25.170><c> world</c><00:09:25.260><c> can</c><00:09:25.500><c> claim</c><00:09:25.740><c> the</c><00:09:25.860><c> bounty</c>

00:09:25.940 --> 00:09:25.950 align:start position:0%
anyone in the world can claim the bounty
 

00:09:25.950 --> 00:09:27.980 align:start position:0%
anyone in the world can claim the bounty
just<00:09:26.310><c> by</c><00:09:26.400><c> submitting</c><00:09:26.670><c> the</c><00:09:26.820><c> code</c><00:09:27.029><c> no</c><00:09:27.690><c> human</c>

00:09:27.980 --> 00:09:27.990 align:start position:0%
just by submitting the code no human
 

00:09:27.990 --> 00:09:29.750 align:start position:0%
just by submitting the code no human
interaction<00:09:28.200><c> required</c><00:09:28.680><c> if</c><00:09:28.980><c> it</c><00:09:29.400><c> passes</c><00:09:29.580><c> the</c>

00:09:29.750 --> 00:09:29.760 align:start position:0%
interaction required if it passes the
 

00:09:29.760 --> 00:09:33.440 align:start position:0%
interaction required if it passes the
type<00:09:29.910><c> checker</c><00:09:30.150><c> you</c><00:09:30.690><c> get</c><00:09:30.870><c> paid</c><00:09:32.390><c> and</c><00:09:33.390><c> that's</c>

00:09:33.440 --> 00:09:33.450 align:start position:0%
type checker you get paid and that's
 

00:09:33.450 --> 00:09:35.660 align:start position:0%
type checker you get paid and that's
formality<00:09:34.020><c> Thanks</c><00:09:34.770><c> happy</c><00:09:35.430><c> to</c><00:09:35.520><c> take</c><00:09:35.610><c> any</c>

00:09:35.660 --> 00:09:35.670 align:start position:0%
formality Thanks happy to take any
 

00:09:35.670 --> 00:09:37.310 align:start position:0%
formality Thanks happy to take any
questions<00:09:36.300><c> I</c><00:09:36.570><c> don't</c><00:09:36.720><c> think</c><00:09:36.870><c> I</c><00:09:36.930><c> have</c><00:09:37.020><c> any</c><00:09:37.140><c> time</c>

00:09:37.310 --> 00:09:37.320 align:start position:0%
questions I don't think I have any time
 

00:09:37.320 --> 00:09:40.050 align:start position:0%
questions I don't think I have any time
okay

00:09:40.050 --> 00:09:40.060 align:start position:0%
 
 

00:09:40.060 --> 00:09:43.180 align:start position:0%
 
[Applause]

