[MUSIC PLAYING]
ANDREW: I'd like to
introduce Emmanuel Schanzer.
Emmanuel is a creator
and co-director
of Bootstrap, one of the largest
formal K through 12 computer
science initiatives in the US.
He spent several years as a
program manager and developer
before becoming a high school
teacher and a middle school
academic coach,
and has long been
involved in connecting
educators and technology,
building partnerships with
professional organizations,
universities, and companies
from across Silicon Valley
to bring rigorous,
high-quality CS
education to all
students, particularly
underrepresented groups.
He holds degrees in computer
science and curriculum
developing, and
his research focus
involves using programming
to teach algebra.
EMMANUEL SCHANZER: Cool.
All right.
Well, thank you.
Well, hi, everybody.
[APPLAUSE]
Aw, thank you, thank you.
I haven't even started.
So I want to thank all of
you for being here today.
And also, as I mentioned
before, I really
appreciate you taking a moment
away from the Comey testimony
to join us here.
So it's great to be back
at Google, so thank you
for having me.
I especially want
to extend a thanks
to Andrew for the invitation,
for setting this up.
And I'm going to spend
the next 35 or so minutes
talking to you about computer
science education formulated
as an engineering problem.
So as Andrew mentioned,
my name is Emmanuel.
I work with a team.
Their names are up
here on the slides.
Shriram Krishnamurthi, Kathi
Fisler, and Emma Youndtsmith.
And Bootstrap right now is
one of the largest formal
in-school programming
courses in the country.
We reach about 20,000
students every single year.
Most of these students are
taught by teachers with little
or no computing experience.
43% of our students are
girls and young women.
46% self-identify as
African American or Latino.
So if you're counting
these numbers,
these are pretty good in
the CS education business.
A lot of these
classes often struggle
to recruit
underrepresented groups.
I'm going to tell you
a little bit about how
we did what we did,
where we're going,
and hopefully pass on some
of those lessons to you guys,
especially since
you are engineers.
And I think this is a
problem that you guys have
a unique way of looking at.
Engineers broadly.
Also sales, GOs here as well.
I guess GO engineers.
But Googlers overall.
So let's start with a question.
Somebody walks into
your office and says,
you know, I want to
teach computer science.
You guys are the expert.
You work at Google.
So what language should I use?
So I'm just curious.
Take a second.
I want to hear, like, a
couple of suggestions.
Like, three folks.
What would you recommend to
someone who's asking you this?
AUDIENCE: Scratch is a good one.
EMMANUEL SCHANZER: Excellent.
Scratch.
What else?
AUDIENCE: Python.
EMMANUEL SCHANZER: Python.
Great.
One more.
AUDIENCE: I'd recommend Lisp.
EMMANUEL SCHANZER:
He recommends Lisp.
Great.
OK.
There's always one.
[LAUGHTER]
All right.
Sounds good.
And this, in fact, is
exactly the way it goes.
So here's an example of
an actual Facebook thread.
Someone asks-- there's
one post and it says,
hey, I'm looking for advice
on teaching some coding.
What do people
think I should use?
And the responses are all
things like Scratch indeed
was the first one.
Someone else is
recommending some Logo.
Someone else is looking at--
let's see.
They're talking about maybe
C++, maybe Java or Python.
So the answers are
all immediately,
here are some languages.
Here are some tools.
Let me ask you a slightly
different question.
Someone walks into your
office and says, hey,
I want to make software.
You guys are Googlers.
What language should I use?
So what do you tell them?
AUDIENCE: No, no, no.
You ask, what software--
type of software?
EMMANUEL SCHANZER: So
you would push back.
You'd say, well, what kind
of software do you want?
AUDIENCE: Like, if
it's an Android app,
you have to use Java.
If it's an iPhone app, you have
to use C, effective C, or Swift
or something.
EMMANUEL SCHANZER: Yeah.
You're saying that maybe before
you answer with the language,
you would ask a little
bit more about what
this person's trying to make.
Right?
Even if they came to you
asking for a language,
you're saying, well,
back up a second.
What do you want to do?
And I think that's
sort of telling
that when someone asks an
engineer what language should I
use, the engineer says, back up.
What are you trying to do?
But when it comes to
education, if a teacher says,
what should I use,
we're instantly
quick to jump in and say,
you should use C Sharp.
You should use Scratch.
Things like that.
Why?
I mean, as engineers, the
first thing we should be doing
is looking at, what are the
constraints of the problem?
So here are some
educational constraints
that we should be
asking before we
answer that teacher's question.
How old are the students?
Right?
Maybe they're 30.
Maybe they're five.
That might change our
answers a little bit.
Have they had prior
programming exposure?
Is it their first
programming class,
or did they have masters
degrees in computer science?
Is it a required
class where you're
going to have every kid there,
or is it self-selected kids?
How long is it?
Right?
Is this to run an all-day
summer camp, eight hours a day,
every day?
Or is it, like, a half an hour
coding club, Monday mornings?
Is it even a class?
Maybe it's a drop-in coding
club over at the local science
museum, and some kids
are there every day,
some kids show up once and
you never see them again.
Now I think if I had
given you guys more time
to think about
this question, you
would have come back with
some of these constraints.
You would have asked about them.
But there are some other
constraints that you might not
have thought of.
So if you're interested in
getting computer science
into an educational context,
you should also ask yourselves,
how many kids are there, right?
Is it one teacher teaching
a giant lecture hall,
or is it just a
small group of kids?
Similarly is there internet
access in the school
or in the educational setting?
Is the teacher new
to programming?
Maybe the teacher has
never coded before.
Can the students type?
That is a critical question
that might immediately
lead you to say, well, you
know, Scratch is a great place
to start if they can't type.
Are there students with
different ability levels,
right?
Are they visually impaired?
Do they have sensory
motor impairments?
If you're talking about
schools, the answer is yes,
and you have to ask what
those impairments are,
what the different ability
levels are, because those
will change your answer
do they have regular
computer access at home?
Because if you're teaching
a programming class
and you're relying on kids
completing programming
assignments for
homework, this matters.
And in fact, do they even
have regular computer
access at school?
Right?
I mean, if a teacher says, I
want to teach computer science,
we often think, oh, you
must have a computer lab.
Kids must have
computers every day.
Often what it really means is
there's, like, a laptop cart
that comes around on Friday.
So these are the
constraints that we
need to ask about
before we even barge in
and say, well, here's
how computer science
education should work.
And you know, as
computer scientists,
we often overfixate
on the tool, right?
We jump into the language.
We jump into the software.
Which is why I think, when
you look at the last 40 years,
the history of CS education
is a history of tools.
Here's the new tool that's
going to change the way
programming is taught forever.
And then 10 years later,
here's the new new tool
that's going to change the way
programming is taught forever.
And this endless cycle
never gets us anywhere.
So let's look at
this as engineers
and say, let's
define the problem.
What are our constraints,
and what are our metrics?
We've talked about
our constraints.
I'm going to posit
that there are three
metrics we should consider.
So first is equity, right?
Without equity, we could
get computer science
into every school,
and then the only kids
who show up for the class
are rich white boys,
and I think none of us
would be thrilled with that.
So equity is number one.
We also want scale, right?
We need this to be reachable by
millions and millions of kids.
And you've got things
like Hour of Code
that reach millions
upon millions
of kids, all kinds of kids.
But even code.org, even Hadi
Partovi himself would say,
Hour of Code is not
rigorous education.
It's merely exposure.
What we want for our
third criteria is rigor.
If we haven't got
all three of these,
I would propose that we're
never fully successful.
We're never where we need to be.
So with these goals in mind,
let's look at the solution
space, because there are sort
of four strategies that people
tend to use when it
comes to CS education.
So the first is, let's
make it a required course.
Every child in America
must take computer science
before they graduate, OK?
There's a riff on this,
which is, no, no, no, no.
There should be a computer
science course in every school,
but it's optional.
It's an elective
that kids can choose.
Option three.
Forget all of that.
We're going after school.
And option four,
maybe instead we
try to integrate computing
into some existing mainstream
classes.
So let's look at these four.
And I just want to say that
all four of these strategies
have merit.
So as I go through this, some
have strengths and others have
weaknesses, and that's fine.
I think there's
room in this space
for a plurality of approaches.
So let's start with the
required course, right?
Let's talk about that strategy.
Well, the problem
with required courses
is that this strategy
doesn't scale.
If we really wanted to
get computer science
to be taught to every
child in America,
we need to do four things.
First, we would need to have
something called CS teacher
certification in
every single state
so that a teacher could
become a CS teacher.
And right now, less
than half of the states
have such a certification.
So that means a
policy effort that's
going to take a lot of years
and a lot of dollars to create.
And then once
that's done, we need
to recruit and train at least
20,000 full-time, dedicated CS
teachers.
And that's even more years
and even more dollars.
And then let's just assume
that none of those teachers
decide to peace out and go
work for a technology company,
because now they can make
a whole lot more money.
Let's just assume they all
stay in the classroom, right?
We still have to pay
their salaries, which
means at least a
billion dollars a year
added to the national
education budget
in every single
year in perpetuity.
That's not going to
happen anytime soon.
But suppose somebody with deep
pockets opens them up and says,
I'm going to pay for all of it.
It's totally OK.
Well, beyond paying
their salary,
there's also the laws
of time and space,
and there's a finite number
of hours in the school day
and rooms in the
school building.
So where are these CS
classes going to fit, right?
It's essentially a nonstarter.
So there's a lot of benefits
here, but right off the bat,
we give up on scale.
That's not happening
with this strategy.
Even worse, if it's
a required class
that kids need to
complete to graduate,
that means you have
wildly different ability
levels in that classroom.
And because it's a
graduation requirement,
there's a perverse incentive
on the part of the teacher
to get rid of the rigor, right?
To make sure that every
single kid can pass it,
because we don't want kids
dropping out of high school
because they didn't
pass their CS class.
So we may lose some
of the rigor as well.
AUDIENCE: Do this happen in
every course [INAUDIBLE]??
EMMANUEL SCHANZER: Well,
I mean, it often does.
AUDIENCE: I mean, I was a
teacher for [INAUDIBLE] years.
That's why-- I mean, I agree
with everything you've said
so far, but that strikes
me as sort of a--
EMMANUEL SCHANZER: And that's
why it's shaded, right?
So some teachers
will hold the line.
Some teachers will say, no.
I'm going rigorous
the whole way.
AUDIENCE: The scale thing,
I think you're 100%.
I actually agree with
everything you said.
But that one doesn't
strike me as [INAUDIBLE]..
EMMANUEL SCHANZER: And that's
why it's half on there, right?
I think some teachers
will take the approach
that you would take.
There are other teachers
that are going to say,
you know what?
I wasn't even a CS major.
The fact that I don't know
this computer science class,
I don't want any kid
to fail, so we're just
going to do something that's
fun and sort of easy to pass.
And that's merely a risk.
It's not a definite outcome.
So let's take a look
at strategy number two.
What if computer science were
simply an elective, right?
That solves some
of these problems.
Well, the problem
with elective courses
is that they're not equitable,
and I'll tell you why.
So every school has a set
of graduation requirements.
So here's a hypothetical
grid of courses
that a student might take
in different subject areas
years one through four.
And you can clearly see there's
room for computer science
there.
What happens if a kid
fails a required course?
For example, algebra 1.
Well, then they have to retake
it their sophomore year,
so we've just moved this
pathway down a notch.
But they're also doubling up.
The school will typically assign
them to a second math class,
like a remedial
math class, to make
damn sure that that kid passes
their algebra class this time.
And of course, they're missing
their fourth year of math.
So what happens?
They get another year
added somewhere else
in a different track--
maybe financial math, applied
math, something like that--
to give them the
credits that they need.
And then over on
the science column,
you'll notice that virtually
every science has algebra
as a prerequisite, right?
Without algebraic
functions, you're
not modeling projectile
motion in physics.
You're not balancing
chemical equations.
So often, there's
a delay introduced,
a bubble in the pipeline.
And that's if they
fail a class once.
What if a kid fails two classes?
You had this nice
grid structure that
allows for all these
courses, but now there's
this cascade of errors.
That means that these students
don't have room in the schedule
to take the electives.
So for students who
fail these classes,
they're Xed out
of these options.
And when you look at the
students that typically
struggle in the
mainstream classes,
often they split along class
lines, poverty lines, SES.
And because of some structures
that we have in America,
those are also divided
along racial lines.
So these elective courses
are great to have,
but it's no surprise that when
you look at the courses that
are being offered
right now as electives,
often there's a particular
profile of student who winds up
being in the classroom.
So going back to
our scorecard here,
you know, we lose
equity off the bat.
And I think that there is often
something of a risk in losing
rigor, and I'll tell you why.
Because for a school that's
just offering a single computer
science elective, it's
not cost-effective
for them to hire, like, a
full-blown computer science
teacher.
So what are they going to do?
Who's going to teach that class?
AUDIENCE: Math.
AUDIENCE: If you're
lucky, a Math.
Teacher.
EMMANUEL SCHANZER:
Maybe a math teacher,
maybe a history teacher, right?
They'll ask another teacher
to take over that class, which
means we lose the ability
to ensure that they
have the necessary training
and depth of content
to ensure rigor.
So again, rigor is
sort of a risk here.
So let's take a look
at strategy three.
What if we did-- what if we just
bypassed the schools altogether
and did computer science
as an after-school program?
Well, this is a strategy that
I can tell you a lot about.
So Bootstrap began as
an after-school program.
And several years back,
early in our growth,
we were actually one of
the largest after-school
programming curricula
in the country.
And in fact, we had
tons of engineers
from Google who taught the
class in after-school programs.
And when we looked at the impact
we were having, we shut it
down.
That's a battle scar,
and I'm going to tell you
my reasons for doing so.
See, the problem with
after-school computer science
is that by definition,
it has to compete
with after-school football,
basketball, theater,
sculpture, having a job, taking
care of your little brother.
Which means the only kids who
show up for after-school CS
are the kids with the means
and inclination to do so.
They already see themselves
as interested in coding.
So equity goes out the
window very, very quickly.
Once you scale beyond a
certain group, you lose equity.
But there's
something else, which
is that after a long day of
school, kids are exhausted,
justifiably so.
Which means it's
extremely hard to teach
a rigorous after-school
program in class.
Now this is not to knock
after-school coding clubs.
I think they're fantastic.
I think they add a lot of value.
But I think often
the critique that you
hear is, this after-school
thing, it's really great.
Kids are getting
engaged, but I wouldn't
say they're learning
rigorous computer science.
So easy to scale, but you
risk losing some other stuff
as well.
So we sort of ruled out
the first three strategies
as having some benefits, but
not necessarily getting us
to all three of our
metrics for success.
So I want to pause for a second
and give you an inequation.
The idea that everyone should
learn computer science does not
mean everyone should take
computer science classes.
I think this is a
tenuous connection
that we need to sever.
So I want to talk about
the fourth strategy, which
is, what does it look like
to integrate computing
into a mainstream course?
And if you were to pick
a course, any course,
I think you'd want to pick
algebra, and I'll tell you why.
So first, algebra is
the gateway to all STEM.
As I mentioned before,
you fail algebra 1
and you just give up on
math right there, yeah,
you're screwed for the
M part of STEM, right?
You're not going to
become a mathematician.
But you're also not going
to become a physicist
without functions.
You're not going to become
a chemist, a biologist.
Even if you want to go into
economics, financial literacy,
you need to know
algebraic functions
if you want to model things
like compound interest.
So a kid who flames
out of algebra 1
has essentially made a
career decision, where
they're Xed out from STEM.
In fact, this impact
is so significant
that a 2004 study looked at the
correlation between grades kids
get in high school and
their lifetime earnings.
And what they found was that the
grade a child gets in algebra 1
is the most strongly correlated
of any subject with the amount
of money that child
will make for the rest
of his or her life.
And finally, we live in an
era of high-stakes testing
and standardized
tests, and algebra 1
is a requirement in every single
school in the United States.
Which means that the
superintendent of New York City
public schools isn't
staying awake at night,
shivering, saying, why aren't
my kids learning to code?
What they're really
worried about is,
are my kids going to be able
to pass the algebra exams?
And this is happening
nationwide, right?
Typically, when you
hear people compare
how we're doing to
other countries,
the thing that scares us
the most is other countries
are beating us in math.
And guess which part of the
math test people freak out
about the most?
The algebra.
It's the word problems.
AUDIENCE: What about geometry?
Just curious.
EMMANUEL SCHANZER: I mean--
AUDIENCE: Or is that
not required everywhere?
EMMANUEL SCHANZER:
Not only is it
not necessarily
required everywhere,
but typically, when you
think about Americans
who are scared of
math, it's always
the train leaving Chicago and
the train leaving New York,
right?
It's this, like, nightmare
word problem that we all
giggle about, right?
Because it's true.
We have, like, national PTSD
when it comes to algebra.
So this is a class
that's in need of help.
So what if we tried to
teach computer science
through the algebra class?
What if we integrate it?
So I'll make a
strong claim here,
that the integrated strategy
is scalable, equitable,
and rigorous.
Here's why.
It's scalable because every
child takes algebra, right?
You're immediately reaching
every child in the country.
You're leveraging
the huge network
of existing teachers, courses,
and professional organizations
that are already out there.
So we can grab that
scale and run with it
to teach computer science.
It's also equitable.
You know why?
Because everyone takes algebra,
which means right off the bat,
you're removing the
negative stereotypes
that are accidentally reinforced
by things like electives
and after-school clubs where
when other kids look at who's
taking those courses,
they say, oh,
that student doesn't
look like me.
But if you're in the algebra
class, we get rid of that right
off the bat.
We're all in it together.
And it's also fairly
rigorous, right?
The content in
algebra is well-suited
to rigorous instruction
and evaluation.
Algebra teachers confront
issues of abstraction
and formal notation
all the time.
There are some great
corollaries here
that we can put to use to
teach in computer science.
So you're probably sitting
here saying, oh my God.
Emmanuel is telling me
that this is basically
a free lunch, right?
We get all of those
metrics for free.
It's fantastic.
Do you believe me?
AUDIENCE: No.
EMMANUEL SCHANZER: No.
Because there's no such
thing as a free lunch.
So here's what we do.
We've essentially traded
one set of challenging
constraints for a different
set of challenging constraints.
So rather than trying
to jam computer science
into a resource-starved
educational context, now
we have a different
constraint problem to solve.
If we want it to fly, we
have to have transfer,
which means the computer science
kids are learning in the math
class had damn well better
result in them learning math
better than they did before.
Otherwise, the math
teachers are just
going to revolt.
They're going to say,
I don't care how cool this
is or how useful it is.
My job is to teach math.
And if I'm giving up
time for my math class,
it better result in
improved math outcomes.
Right?
So in cognitive
science literature,
this is a phenomenon
called transfer.
Transfer is pretty simple.
A skill learned in one context
can be used successfully
in a different context.
That's our goal.
And it turns out that
transfer happens all the time,
but almost never in
the way you expect.
If you want to actually
guide kids to transfer,
it's much harder than you think.
So how do we guide kids
from transferring skills
and computing into algebra?
Well, we know that there
are three new constraints.
Number one, you have to
have explicit instruction.
Having a kid perform
task A and then later
having them perform
task B, A and B might
seem similar to
you, but you have
no guarantee that student is
going to make the connection.
And often, without having
a teacher in the room
to explicitly tie
the two together,
it ain't going to happen.
But that's OK, right?
We're dealing with
math teachers,
so we can check that one off.
Phew.
Number two.
The tasks that you're
using in domain A and B
have to have deep
structural similarities.
How deep am I talking about?
I'll give you an example
from a 2009 case study.
They looked at a
physics teacher who
was talking about
gravity and acceleration,
and had his students do
tons and tons of problems
where a ball was dropped
off of a tower or off of--
I don't know-- out of an
airplane, things like that.
And they studied
how fast the ball
was moving after a given time,
where it was after a given
time, all sorts of stuff.
And then they gave
the kids a quiz.
The quiz had balls being
dropped down holes,
and the students complained.
You know why?
You didn't show us
any hole problems.
So the level of
structural similarities
needs to be insanely
high in order
to really facilitate transfer.
And finally, you need to have
a process for performing tasks,
right?
You can't just give kids
a problem in domain A
and then assume that
they will magically
understand how to transfer
that to solving that problem
in domain B, right?
A classic formulation
of what I just said
is we often think that we're
teaching kids problem solving
simply because we give
them problems to solve,
and that's not true.
So we've got to have
an explicit task.
So these are our new criteria.
We've already got one.
Let's talk about how
we get number two.
Deep structural similarities
between computer programming
and algebra.
Well, there's a
problem, because most
of the coding that we do
in K-12 doesn't actually
have functions,
and functions are
kind of important for algebra.
So a lot of teachers will
use function machines, right?
There's inputs and outputs.
There's a vertical line test.
Except often, you have functions
that return void or functions
that you give them the
same input 10 times,
you get 10 different outputs.
This is perfectly common in
many programming languages.
There's no computed
output, right?
Here's a block from a language
you might be familiar with.
What's the output
of that function?
There's nothing computed
that's showing up.
So for a teacher who's
trying to make connections
between the functions on a
computer and the functions
in algebra, this doesn't fly.
Coding also doesn't have
variables for the most part.
Here's a classic
example from Python.
x equals 10, and now
x equals x plus 2.
When you run this program,
what's the final value of x?
Class?
AUDIENCE: [INAUDIBLE].
EMMANUEL SCHANZER: Fantastic.
Actually, no.
That's not right at all.
I'm a math teacher.
This is nonsense.
[LAUGHTER]
And you can probably guess why.
And there's actually
two problems here.
One is-- well, can you guess
what one of the problems is?
AUDIENCE: There's no [INAUDIBLE]
meaning of the equals sign.
EMMANUEL SCHANZER:
Yeah, we're overloading
the equals sign, right?
We're treating
something that has
a clear definition in
mathematics to mean assignment,
right?
Assignment is not equality.
So that's a syntactic problem.
But there's something
much deeper at work here,
which is the semantic problem.
Because assignment
does not exist in math.
And for those of us who know
that sometimes state can
be a little bit hairy
when you're writing code,
state is a known challenging
thing for young programmers
to get a handle on.
And that's hard in a
programming course.
Now we're going to ask math
teachers to teach that, and at
the same time, sufficiently
differentiate it
from the equality
concepts that they're
learning in the math book.
So this is a very tall order.
And it gets worse,
because coding also
doesn't have numbers,
and you kind of
need numbers to do math.
What do I mean by that?
Well, of course, you guys
know what 1 over 2 is, right?
What's one over two?
It's zero, right?
Because in Java,
that's what you get.
And you might say, oh,
Emmanuel, you're just being--
you know, you're
just being silly.
A teacher needs to make sure
that they're teaching kids
to declare things as
a float, not an int.
Maybe that's true, except
in a math class, that's
not part of the standards.
And so now we're
asking math teachers
to teach kids about
these different partial
representations of numbers.
Which, again,
takes valuable time
away from actually teaching
math, and that's a problem.
But of course, these
partial representations,
no matter which one
you pick, you're
going to get burned
one way or another.
A math teacher will often teach
kids this important property.
If I have three
numbers A, B, and C,
these two expressions
are equivalent.
Y'all agree?
[LAUGHTER]
What if A plus B is too big?
For Maybe A minus
C buys us some room
before we have an overflow,
so the bottom one computes,
but the first one
gives us an error.
Or maybe vice versa.
The bottom one has
an underflow error.
So this statement that these
two expressions are equivalent
is now wrong.
In a math class, it's wrong.
And it gets even worse, because
let's say we use those floats,
for example.
Well, floats introduce
error, right?
Which means that these two
expressions are no longer
equivalent either.
We've just broken associativity
and distributivity
in a math class, and
we're going to ask a math
teacher to teach it too.
Even if we could, these are
known obstacles for transfer.
So if your goal is
teaching algebra,
this is deeply problematic.
So what do we do in Bootstrap?
Well, we decided, you know what?
Functional programming is a
pretty decent way to do this.
It enforces much more
algebraic behavior.
We chose a language that
has a strong numeric tower
implementation, so
numbers behave as close as
is reasonably possible
to the numbers that
behave in the book.
So we get a lot of the deep
structural similarities.
And then we actually do
programming using word problems
taken from a math book.
So we get some of that for free.
But what I want to get
back to is this idea
that the takeaway should not
be, functional programming is
awesome, right?
Functional programming
is necessary
if your goal is algebra,
but it is not sufficient.
You also need a curriculum that
uses functional programming,
because the
curriculum is critical
if you want to teach the process
for performing those tasks.
So I'm going to explain this
using an extremely scientific
graph, so pay close attention.
This is very, very scientific.
We can graph a student's
frustration level
as a function of the
number of lines of code
that they've written.
And typically, it looks
kind of like this.
So you give kids a
programming challenge
and you say, all right, kids.
Solve it.
So they fire up the editor
and they're starting here.
They're going, I don't
know where to begin.
That first line of code is
sometimes the hardest line
for a kid to write.
Sometimes even for an adult.
This is essentially called
the blank page syndrome.
They're like, where do I begin?
But eventually, maybe with some
prodding from the instructor
or maybe on their own, they
start writing some code.
They're starting to
get things going.
Their frustration
level goes down.
And students are kind of
like 3D printers, right?
They work by additive
manufacturing.
So every time they encounter
a bug or every time
they encounter a new feature,
what's their solution?
AUDIENCE: Add more code.
EMMANUEL SCHANZER: Add
more lines of code.
Just more and more
lines of code.
And gradually, the complexity
goes up, and they hit a bug,
and the way around the bug is,
I'll just check for that case
and I'll add more lines of
code and so on and so forth.
But eventually, this path
becomes unsustainable,
and it gets harder and
harder to fix those bugs.
And eventually, the kid
raises their hand and says,
my program doesn't work.
I'm stuck.
This is a common pattern in
computer science education.
And those of us in
the room who may
have done some teaching
of computer science
may have seen some
of this play out.
Now how do you deal with that?
Well, let's look at any
other discipline, right?
Every discipline works in
a completely different way
from this idea.
They have-- like architects.
Architects don't start by
pouring concrete and then
just adding stuff until
you get a building.
Right?
They have 3D models,
they have blueprints.
Let's say you're
building a device.
Maybe you're building
the first mouse, right?
You don't start by ordering
a manufacturing prototype
and then adding to
it until it works.
You probably think it through
with some circuit diagrams,
maybe some other kind of model.
The point is, we don't
just jump to the solution
and start hacking at
it until it works.
Typically, what
we do is we follow
some sort of multi-stage
path to a solution, right?
We start with one thing,
and then we build on it.
And that one thing is not
the same representation
as the finished form.
An architect might start with
a blueprint, not concrete.
So we have these
multiple representations
that we pass through on
the way to a solution,
and each representation
represents
a different perspective
on the solution.
So one representation might
be great for answering
one category of questions, and a
different representation better
for another category.
This multi-dimensional
view is also
present in software
engineering, right?
Often there are specs.
Often there are test cases.
Often there are user interaction
specs that are written up.
There are lots of things that
you go through before you
just instantly start coding.
And it turns out that there
is a multi-dimensional view
that every teacher,
every math teacher
cares about too,
which is functions.
Functions have multiple
representations.
I can think of it
as a symbolic form.
I can think of it as
a line on a graph.
I can think of it as a
mapping between domain--
I'm sorry-- a table
of inputs and outputs
and a mapping between
domain and range.
So every algebra
teacher out there
already understands this idea
of multiple representations,
multiple stages, and
multiple viewpoints.
So what does this look like
in a programming class?
So this is an actual worksheet
from the Bootstrap curriculum
that math teachers use.
It's got a fairly
simple word problem.
This one is aimed
at programming.
So in the process of
making a video game--
so every Bootstrap
kid builds a game--
they need to write a
function that controls
the movement of their target.
So we have our word problem.
Write a function
update-target, which
takes in the
target's x-coordinate
and produces the next
x-coordinate, which
is 50 pixels to the right.
Step one, contract
and purpose statement.
We ask students to come up
with a name, the domain,
and the range of that function,
and to write a purpose
statement, an English
language summary of what
that function does.
And then we ask them
to write some examples.
Update-target given 10.
The work it should
do is 10 plus 50.
Same thing for 20.
Then we ask students to
identify the pattern.
What's changing?
What's the rule?
And from there, they can derive
sort of the finished form.
Now as software engineers, this
looks somewhat familiar to us,
right?
That first stage
kind of looks like
having them write a type
specification, and maybe
a comment as well.
That second part looks an awful
lot like writing test cases.
And then of course, the
final representation is,
then you go and write the code.
So students are doing all three.
A math teacher would
totally disagree.
A math teacher would
say, no, no, no, no, no.
That first step, I
know what that is.
It's domain and range.
It's thinking of
a function machine
as mapping between
these two sets.
And that second one?
That's input-output
tables, right?
That's that little--
the T table,
mapping between discrete
input and output pairs.
And finally, I don't know
what that code thing is,
but this is clearly the
symbolic form of a function.
So these representations
dovetail beautifully
in the context of a math class.
So we've got multiple
representations
of code, multiple
representations of functions.
And with this as
a scaffold, we're
able to manage this frustration.
Because at every stage, students
know what's expected first.
The very first thing I do is
write the contract and purpose
statement.
And each one of these gives
you a different perspective
on the problem, a
different viewpoint,
which allows you to build
into the next stage.
So scaffolds are useful.
This is the explicit
task that student--
sorry, that teachers
teach students
how to do when
they're programming
a computer that they
can then transfer over
to the domain of math.
When I'm working
on a word problem,
I'll use the same strategy.
So when you look
at things this way,
we sort of have a
dependency graph
if we want to satisfy
these constraints.
So there are three
things at work here.
You've got to know what
programming language you're
teaching.
If you want to teach
computer science,
what language am I teaching?
You also need to
have a curriculum.
How am I going to teach it?
What activities are kids
going to go through?
And then you need a pedagogy.
What will it look like?
What is the explicit task
that students are learning?
And often, we just pick
one off the shelf and say,
we're teaching Scratch.
Great.
Now let's build a curriculum.
We're teaching Python.
Great.
Let's figure out a pedagogy.
But can you guess what
the dependency graph
looks like here?
AUDIENCE: Probably
pedagogy first.
EMMANUEL SCHANZER:
Well, pedagogy first.
Anyone disagree?
If we were to draw arrows
here, where do they go?
AUDIENCE: I mean, it seems like
you're choosing language first
if you're going
to choose Scratch.
EMMANUEL SCHANZER: Right.
If someone says, I'm
going with Scratch,
they would choose
language first.
But let's say that
you were starting
from a clean sheet of paper.
We want to change CS education.
We want to set up a class
or an after-school club
or a whatever.
What does the dependency
graph look like here?
Is there a dominator?
Are they codependent?
What do you think?
AUDIENCE: I would
say language last.
EMMANUEL SCHANZER:
Maybe language last.
Well, you can approach
it from any perspective,
but all three of them have
dependencies on each other.
The moment you make one
choice in this graph,
you instantly prune the tree
for what you can do elsewhere.
So here's what we did to
build a curriculum that
could be integrated into a
mainstream algebra class.
So I heard a volunteer
say, maybe we
should start with the language.
So sure, I'll start there.
We knew it needed to have
easy unit tests, right?
It needed to be really trivially
easy for kids to create
that input-output table.
So that meant for us
vertical line test.
We really wanted a
functional language
so that we wouldn't
have to manage state.
We also wanted
first-class images,
because images are
engaging and fun,
and it's really nice if kids
can just write some code
and see the output right
away as a computed output
from the function,
rather than worrying
about setting up
a buffer somewhere
and then retrieving it.
But most importantly, we
wanted mathematical semantics.
We wanted to have that
deep structural similarity
between tasks.
AUDIENCE: Something to add on
the images thing is one of--
the main reasons kids are
scared of the math class is--
well, they were scared
of the previous math
class and the previous
math class before that.
But what the kids think
math is is arithmetic,
and as soon as they see numbers,
their palms start sweating.
So when I've taught
this kind of thing,
we start with images on
the first day of class,
and we get to numbers
about week three or four.
EMMANUEL SCHANZER: Yeah.
So making images
easily accessible,
lowering that
barrier, for some kids
can be a huge
motivational boost.
So these were the
criteria we wanted
that led us to choose
the language we wanted.
And I just want to point out,
we started with the criteria,
not the language.
We started with
those three things.
And from there, we
picked our language.
We didn't decide we
were in love with Lisp,
and we wanted Lisp, for example.
But for our pedagogy, we
used structured problem
solving, right?
Because we wanted to
get that explicit task.
And that problem
solving strategy
had to be
multi-representational.
It had to use worked
examples, because that's
the pedagogy that math
teachers are familiar with.
And we actually borrowed it
from a phenomenal program
that's been running
for more than 20 years
at the university level
called Program by Design.
So it's an effective pedagogy
that's been proven successful.
We poured it into middle
and high school math.
And then finally, you
need a curriculum.
And by the way, for those of you
that are interested in teaching
computer science,
maybe at a local school
or at a summer
program, a curriculum
is not a list of activities.
That is not a curriculum.
A curriculum involves lesson
plans, homework assignments,
exit slips, warm-up activities.
It's aligned to national
and state standards
so that a teacher
knows where things fit.
If you're expecting that
teacher to go and build
this on their own, looking
at a list of activities,
it's not going to fly,
because guess what?
Teachers are really busy.
And the curriculum we developed
has a narrative final project
that ties together everything
students have learned.
Every student in Bootstrap
builds a video game
of their own invention.
And so at the end
of the class, kids
can do a video game
launch party, right?
It's sort of like a science
fair for the math department
where they show off what they've
built in their math class.
We believe that algebra
is the moment where
math becomes creative, right?
You're literally making
your own functions.
You're building your
own mathematical tools.
Well, let's make a
video game out of it.
And so you'll notice that
what kids are presenting here
is not showing off their cool
graphics for their games,
although they do show that.
We actually have
kids do code reviews.
Parents, friends, teachers, and
sometimes visiting engineers
ask students questions.
Why did you do it this way?
What would you have
to change to add
this feature or that feature?
And students are
required to look
at which representation
makes the most
sense to answer that question.
Is it my unit tests?
Is it my type specification?
Or am I going
straight to the code?
So this is something that we're
doing at the middle and high
school level, because we're
building on something that math
teachers already have them do.
Kids are used to going up
to the front of the room
and explaining their solutions.
So that's what we
do at Bootstrap.
That's the strategy
that we've taken.
And you know, we believe deeply
in equity, scale, and rigor.
And we can do this not just
through algebra, but also
through additional
curricular offerings.
So we've partnered with the
American Association of Physics
Teachers to build a
Bootstrap physics module that
does the same thing
for a physics class
that we've already
done for algebra.
And we're also working
on a data science
module that can be integrated
into a high school statistics
class.
Or there are plenty of other
classes that use spreadsheets.
Right?
Business classes,
civics classes.
Right?
There are students
who might want to ask,
I think stop and frisk is
racist, or I think it's not.
And guess what?
That database is
publicly available.
And in the data
science curriculum,
teachers can have students
answer that question themselves
by viewing programs as
questions they ask of data.
And by aligning it
to the standards
that teachers already
have to teach,
we can embed this in
a mainstream class.
Our vision is that
a school should
be able to give
kids at least three,
if not more entryways
into computing
throughout their
high school career,
all without having to find room
in the budget for a new teacher
or room in the schedule
for a new course.
If you want to get
involved, there's
tons of places to help out.
We build compilers.
We create programming language.
We live on the web.
All of our stock is built
on Google technologies.
So if you're interested in
helping out but you're like,
I kind of want to focus
on the engineering side,
there's a ton of engineering
help we could use.
If you wanted to be an advocate,
talk to your local school
or district.
Ask them why their math teacher
isn't using computer science
when they could.
Spread the word at the office.
And of course, if you'd
like to contribute, you can.
Our website is here.
I want to end on this note.
I think Google, more
than any other company
in the world right
now, understands
the importance of disciplined,
sometimes unsexy engineering.
I mean, you guys have
thousands of engineers working
on data integrity, right?
Just to make sure that
one file doesn't get
corrupted when it's
duplicated across a network.
Users don't often see the
magic that's going on there,
but Google understands
that that kind of stuff
is critical for building
a scalable infrastructure.
So often in the tech sector
when we approach education,
we stop thinking about it
as an engineering problem.
We just dive into what we were
taught, what we think is cool,
what we think kids will enjoy.
We lose the engineering
side of things.
This baffles us at Bootstrap.
We've never understood why.
I'm here to tell you that
computer science education is
one of the most
sophisticated engineering
problems in existence.
It's waiting for someone
to step in and do
some of the deep possibly
unsexy engineering work
to create a solution.
At Bootstrap, we've built one
of the largest and most diverse
CS education programs
in the nation,
and we did it at a
fraction of the cost
and with a team of
four human beings.
And we did it because
we looked at the problem
like engineers working
at startup scale.
Imagine what a company
like Google could do.
So I want to leave it there.
I'm happy to answer
any questions you have.
This is an engineering
problem that
is built for a
company like Google.
[APPLAUSE]
Yes?
AUDIENCE: Do you test the
kids with standardized tests
at the end?
EMMANUEL SCHANZER:
Absolutely, yeah.
So the question was,
do we test the kids?
And I'm so glad you asked.
That is literally my
secret last slide.
Whoops.
Load.
This should be mirroring.
Can you guys see my screen here?
AUDIENCE: Yeah.
EMMANUEL SCHANZER: Great.
So the answer is yes.
You better believe
we test the kids.
And in fact, the tests that
we use for our initial study
all involve questions drawn
from national and state
standardized tests.
Not because we're in love
with standardized tests,
but because we understand
that decision makers want
to see that kind of stuff.
And what we've seen is
statistically significant
evidence of fairly large
gains on three tasks
that we've looked at so far.
Function composition,
solving work problems,
and matching between
representations of functions.
AUDIENCE: OK.
So this is pre and post.
This isn't the kids who got this
curricula versus the kids who
got a standard
algebra curriculum?
AUDIENCE: The lower
table is that.
The upper table is preimposed.
AUDIENCE: Is that correct?
EMMANUEL SCHANZER:
No, the lower table
is demographic distribution.
So this table-- so
this table right
here is showing gains pre-post,
not looking at a control group.
I will say that this is
the first curriculum ever
to have demonstrated
evidence of transfer.
We're gathering additional data.
We're building a much
larger dataset that
includes control
groups, so we'll
be able to compare
apples and oranges.
But historically, this
belief that learning code
will help you in math
class has not been true.
The simple fact that
this table exists
was something we're
extremely proud of.
We've been able to
make that happen.
Great question.
Yeah?
AUDIENCE: Yeah,
similar question.
Do you have a
longitudinal study?
So like, you know,
those people who
took Bootstrap, four
years afterwards when they
go to college, when they
actually get their first job?
EMMANUEL SCHANZER:
Unfortunately, maintaining data
on minors is extremely complex.
I mean, I'm with you.
I wish I could stand here
and say we've tracked
these thousands of kids.
We know what happens to them.
We don't.
What I can say is the
schools that have adopted
Bootstrap continue to use it.
And I mean, it's not hard data.
It's proxy and anecdotes at this
point, so I can't answer that.
Yeah.
Yeah?
AUDIENCE: Can you
talk a little bit
about your choice of language?
Because there's a lot of
conversation about what
the AP curriculum uses.
And I graduated from high
school pretty recently,
and there was a lot
of talk about shifting
the the fact of
teaching [INAUDIBLE]
programming through Java
to teaching through Python
because it's more flexible.
And if you teach it
through an algebra class,
it makes sense you would
use something as functional
as Lisp or something to
make it useful to algebra.
But is it still useful
outside of that class
and in a different context?
EMMANUEL SCHANZER: So I heard
sort of two questions in there.
So one of them you
were saying is sort of,
how did we choose
our language, right?
What factors go into it?
And the second is, is functional
programming useful outside
of a math class?
AUDIENCE: Not functional
programming itself,
but the way that
you teach it, does
it make sense to
students that it
would be useful outside of the
context of that math class?
EMMANUEL SCHANZER:
Oh, absolutely.
In fact, the Program by Design
curriculum that I mentioned
is used in universities
around the world.
They actually use the same
language that we're using,
and we borrowed the
same design recipe.
So a student in
Boston can go over
to Northeastern University,
and they will see, oh my God.
The freshman CS majors are
doing the same work that we do.
And in fact, I don't know
if you want to mention this,
because this is a parallel
in New York as well.
AUDIENCE: Well, I'm
no longer at Adelphia,
so Adelphia is no longer
using this approach
in their CS0 class.
But it was for a number of
years while I was there.
Adelphia University is a
mid-level liberal arts school
where I was on the
CS faculty, and we
had a CS0 class,
programming for poets,
programming for non-majors.
And we did it this way.
And we had a fair
number of students
who had such a good time
that they became CS majors.
And they seem to
have learned a lot.
EMMANUEL SCHANZER: So there
are parallels directly
into number of universities
around the world.
But more importantly than that,
yes, functional programming
is in a whole
bunch of companies.
As well, it's used in plenty
of industrial contexts,
so the language
itself transfers.
AUDIENCE: Especially big data.
EMMANUEL SCHANZER:
Especially big data.
That's right.
But more significantly,
this approach
that we're using, the
structured problem solving,
writing a type
specification and, you know,
thinking through your unit
tests deeply before you
dive into the code, that's
a high-level skill that's
relevant no matter what
language you're using, right?
I mean, I went to the bathroom
before giving this talk,
and you know, I think Google
is famous for your testing
on the toilet pages.
You know, this is
something that is
transferable across
languages, right?
This is where you get
the explicit process that
transfers everywhere.
As far as, how do we
choose our language
or why, I think this debate
about, should we use Python
or should we use Java,
it needs to be about,
what is our learning goal?
Computer science teachers
are the only teachers
I can think of of any
discipline that when
you ask them, what do you
teach, their answer is the tool.
Imagine if I asked a math
teacher, what do you teach?
They might say, algebra,
geometry, calculus, right?
AUDIENCE: They're
not going to say--
EMMANUEL SCHANZER: They're
not going to say calculator.
If I ask a chemistry
teacher, what
do you teach, maybe orgo,
maybe some physical chemistry,
you'd think they were crazy
if they answered and said,
I teach Bunsen burner.
[LAUGHTER]
But when you ask your average
CS teacher, what do you teach,
their answer is
Python, Scratch, Java.
It's the only discipline where
they self-identify by the tool,
and that's the problem.
We cannot overfocus on the
tool, because there is this
dependency graph that requires
that we think a little more
broadly.
Other questions?
AUDIENCE: Yes.
EMMANUEL SCHANZER: Yeah?
AUDIENCE: So initially,
you had said you
were an after-school program.
Then you made changes
for that, and you
said you were really large,
and then you stopped.
And I wanted you to expand
on what happened and why
and all that stuff.
EMMANUEL SCHANZER: Sure.
So we actually partnered with
a terrific after-school program
called Citizen Schools.
They're national in scope.
They're very active
in New York, and I
know Google has done some
work with them in the past.
They're great.
I have huge respect.
In fact, I was a Citizen
School's employee at one point.
Here's what we
noticed when we were
doing an after-school
program and club.
So first, we needed
volunteers, so we
had to recruit tons of
engineers, which is not easy.
Second, engineers
are busy people,
and sometimes life
happens, right?
You have a ship deadline,
the build is broken.
So one engineer has to peace
out and can't make it that day.
So what do you do?
You have redundancy.
You recruit three,
four, or five engineers
to make sure that
at least one of them
can be there every single day.
So we have to recruit
five engineers just
to teach this after-school
program, which
is typically how many kids?
Maybe 20.
Maybe 30.
If that.
AUDIENCE: I've done it,
and it's like eight.
EMMANUEL SCHANZER: Yeah.
So we're spending all of our
time recruiting engineers
who need a lot of
training to teach, right?
You guys are experts
at the content,
but teaching is hard too.
So we're investing a ton
in training engineers, five
engineers to eight kids.
And now those engineers,
once you've trained them,
they come back every
semester forever, right?
They just keep teaching.
AUDIENCE: No.
EMMANUEL SCHANZER: No?
What?
AUDIENCE: No.
EMMANUEL SCHANZER: Yeah, right.
So they get busy.
They leave the project.
So you have to recruit
enormous numbers of volunteers
who you lose almost instantly
just to reach 20 kids,
if you're lucky.
A single public
school math teacher
is going to reach 80 to
100 kids in a single year.
And if they like
what they're doing,
if they believe in
the program, they'll
do it forever until
they die or retire,
whichever one comes first.
Right?
So if you're thinking
about scale as a priority,
after school is
amazingly flexible.
There's a lot to recommend it,
but scale is not one of them.
Yeah?
AUDIENCE: I have two questions.
One, you're showing, like,
the math learning here.
Like, what about you
measuring the coding learning?
Is that a separate metric?
Like, how do you
know if the program
is effective on that dimension?
EMMANUEL SCHANZER: So
I mean, essentially, we
use summative assessment.
I'm sorry, formative assessment
throughout the curriculum.
So once we spend about
two lessons teaching
this explicit task, this
multi-representational task,
the moment that's over, every
single thing in the curriculum
is a word problem where kids
are given a problem statement
or problem to solve, and gah.
And so we're able to assess as
they go through the program,
are they able to complete it?
Where are they stuck?
To be really upfront,
the level of programming
we teach in our algebra
module is fairly small, right?
We're not doing
object-oriented programming.
We're not doing, you know,
recursion, for example.
But we have an extraordinarily
high percentage
of students who
finish the program,
build a video on their own.
And we use that as a proxy
for their learning to program.
There are some learning
studies that we're
in the process of doing.
The reason we haven't-- we
didn't start with those are
because for us, we felt that
showing math outcomes was
the most immediate concern.
But we're gathering
data and we're
looking to report on the
CS learning outcomes.
AUDIENCE: And the other
thing I'm curious about,
I was a teacher.
I taught at Success,
which is [INAUDIBLE] one
of the [INAUDIBLE] at
some point last year.
And I'm just curious,
like, what do
you think are the
biggest factors that
lead to schools adopting
or not adopting Bootstrap?
Like, are you bottlenecked
by just the number of people
who work for Bootstrap,
or by school's willingness
to try it out?
Or, like, what are some of
those [INAUDIBLE] factors?
EMMANUEL SCHANZER:
So I mean right now,
our capacity problem is we
do not have enough staff
to train teachers fast enough.
There are far more teachers
who are looking for training
than we can train in a year.
But as far as the
bottleneck at the school,
what makes a school successful?
I mean, I think a
significant part
of that is the
administration needs
to believe in the program.
Because if a math teacher
comes to our training,
gets excited, and then
goes back to the classroom
and starts saying, all right,
we're going to do this,
and the principal looks
in the door and says,
why are kids making
video games, why are they
even on a computer, that
principal, you know,
justifiably might be
hesitant about somebody
messing with their math scores.
And so often, we hear from
teachers who are saying,
I really want to
teach the program.
I wasn't able to get the
administrative buy-in.
So that's a messaging
issue for us.
There is something of
a bottleneck around--
look, some schools do not
have even enough computers
for a once-a-week laptop cart.
That's starting to dissipate.
The hardware problem is
starting to get solved.
But I think the third
most common issue
is sense of teacher support.
So this is an area in particular
where Google can be enormously
instrumental, right?
There's tons of teachers using
Bootstrap in New York City
public schools right now.
I would say a nontrivial
percentage of them
are thinking to
themselves, all right.
I'm doing it.
It sure would be cool if I
could have an engineer just come
and visit my class, like, once
or twice, just to have my back
and to talk to my kids.
That boost, that
sense of, there could
be someone I could call upon,
that would be tremendous.
Even if that teacher
never calls on you,
just knowing that they could can
be the difference between them
teaching it or not teaching it.
So I think those are the
top three bottlenecks.
AUDIENCE: That last point
seems pretty solvable.
I think people would
sign up for that.
EMMANUEL SCHANZER:
I think people--
I hope people would.
Yeah?
AUDIENCE: It is
Google Serve month.
EMMANUEL SCHANZER: There you go.
Oh, is it?
Perfect.
Yeah?
AUDIENCE: So I did
Teach For America,
and I taught algebra
1 for two years.
So I just, like, try to
put myself in the shoes--
and I feel like you kind
of touched on it just then.
But teacher buy-in is probably
something that's very tricky,
just because I can see--
it's like the teachers
in my school, ones
that have been there for
30 years, every year,
there's some new
way to teach math.
And they're like, listen,
I've got it down by now,
and they kind of discard it.
But on a bigger scale, on
district and kind of federal,
where are we?
Because eventually, you feel
like we get to the point
where this curriculum
would be required.
Or, like, it's so
ingrained in our society
that we would need to have
it on kind of a bigger level.
Like, where are we in that?
EMMANUEL SCHANZER: We're not
even at the starting line.
So in terms of
teacher buy-in, that's
something that we excel at.
I'm a former math teacher.
So in our trainings, we are
math teacher to math teacher.
We focus heavily on the math.
Typically, we don't mention
the computer science
learning outcomes, because
we're there to talk math.
And the veteran teachers
buy in at a deeper level
than the young bucks, because
the young teachers are
like, finally, computers, cool.
They're not necessarily thinking
about the math connection.
The veteran teachers see it.
So we've been fairly
successful there,
and it took 10 years for
us to get to that point,
so it's not an easy thing to do.
But as far as the
federal level goes,
it's a hard engineering problem.
Right?
Scale comes not from
getting to 10 million kids
in your first year.
It comes from building
up a pool of teachers.
Maybe you only train
1,000 teachers a year,
but every teacher you
train keeps doing it
until they die or retire.
Right now, the
trend and scale is
how to get to 10 million
kids in year one.
And if that's the
threshold, guess what?
YouTube videos.
We'll do YouTube videos to
teach math through programming.
Like, it's quick,
it's easy, it's cheap.
You don't get the
rigor, and you don't get
teacher buy-in for that either.
I think a lot of governors
have made some really
terrific proclamations about
getting everyone to code,
and then it falls to the
superintendents in their states
to figure out how
to make that happen.
And what winds up
happening is, well, we
used to have this class
on PowerPoint and Excel.
That's kind of like
a programming class.
Let's have that count as CS.
So sometimes we're
repurposing an existing class
and calling it CS.
Or we're doing Hour of Code.
One hour a year,
every kid does it.
We've taught computer science.
Check.
Or we'll take the elective
route, which has its benefits,
but it also has some drawbacks.
So I think in order for there
to actually be a policy movement
on this, someone needs to tackle
the engineering problem and get
buy-in and say, this is--
we're going to build
something scalable,
but it's not going to
happen in one year.
And unfortunately,
that sales pitch
is hard to make when
someone else says,
I can do it in a year,
and I can do it for cheap.
All I need is a video crew.
Yeah?
AUDIENCE: So what you
just said about the issues
that you have--
I've taught [INAUDIBLE]
schools for several years.
And I pretty much
agree with everything
you said about the issues about
how it requires a lot of it--
a lot of expensive resources.
It takes a long time to build
up and all of this stuff.
So what would be--
would you have advice
for people that
are interested in doing
this type of stuff,
and actually would
like to dedicate
some time over the long term?
Like, how do we approach
this type of problem?
Like, for people
that aren't going
to go and, like, start or
join Bootstrap or something.
EMMANUEL SCHANZER: Well,
what are your constraints?
Are you thinking, like, career
change, or are you thinking--
AUDIENCE: No, I'm
thinking, like, what
would be the type of thing that
you could do for a couple hours
a week and have a useful
and meaningful impact?
EMMANUEL SCHANZER:
So I think this--
that kind of thing
is where you can
be complementary to an
after-school organization
like Citizen Schools, like
After-School All-Stars, right?
Maybe you personally
decide, I'm going
to invest in teaching
an after-school program
and class through one
of these programs,
but I'm going to be responsible
for recruiting and maintaining
a rotating community of
volunteers, of coworkers.
And I'm going to make sure
that they get trained.
And since maybe you've
done it two or three times,
maybe you can be the
one to train them.
If you keep that
pathway sustainable,
you can start to
have a bigger impact.
Option two, connect with an
organization like Bootstrap
and say, I want to be
available for any teacher who
has questions.
I would love to just be able
to work with those teachers,
even though I've only got
a couple of hours a week.
I think-- you know,
there are summer camps
that they don't necessarily hit
the equity angle all that well,
but you can do so much when you
have kids for eight hours a day
for three, four, five weeks.
I mean, you can do a lot there
without having to give up
an entire part time year.
AUDIENCE: That's interesting.
Thank you.
EMMANUEL SCHANZER: Yeah.
All right.
Well, I know our time is up.
I know everyone
is really curious
to hear about the
testimony that came out,
so I'll leave you guys to it.
But thank you so
much for having me.
Thank you, Google, for
all of the technology
that we have built
our platform on.
So we really appreciate it.
And thanks especially
to my host, Andrew,
for setting this up.
[APPLAUSE]
