DAVID J. MALAN: Hello, world.
This is CS50.
Can everyone hear me OK?
Yes?
Well welcome to the
CS50X Educator Workshop.
This is a now annual tradition of
ours via which we bring together
educators from the around
the world such as yourselves
to talk about how you might adopt or
adapt CS50 or any of CS50s courses,
and also ultimately to create
a community of teachers.
So that whether your teaching
here in the US or anywhere abroad,
even if you're the only computer
science teacher in your school
or your community or the
like, you nonetheless
have a whole community of teachers as
well as classmates around the world.
So for those of you
less familiar with Zoom,
allow me to draw your attention
to just a few features.
Probably along the
bottom of your window,
you should see a button that's
called participants or something else
in your own language.
If you click on
participants, that should
open a side window that will
show you everyone else here
who is in the room at this moment.
And if you look at long the bottom
two, you should see a chat button.
And if you click on the
chat button, a chat window
should appear below that
participant's window
where you can chat with
fellow participants.
Now I won't be able to really keep
a good eye on the chat window today,
but I'll do my best with
Brian to see if we can
field any questions that come there.
But we'll have
opportunities for questions
and answers throughout
this session and others
by way of another feature of Zoom
namely raising a blue digital hand.
So if you look at the
participants window
you should see a blue button
that looks a little like this.
If everyone wouldn't
mind trying to click
that to raise your hand virtually.
You should see below the
participants, window a blue hand.
That'll be the visual cue to me
and to Brian and to CS50's team
here that you have a question.
And we will do our best to answer.
Please do forgive.
We have a lot of people in the
room, and we won't necessarily
be able to take all questions live.
But we'll provide you
with contact information
via email and the like via which you
can follow up with questions as well.
And because there are so
many people in the room,
we're going to keep
everyone muted by default.
But if I'm able to call on you for
a question or an answer from you,
we will display a pop up on your screen
that will allow you to unmute yourself,
and we'll spotlight you
for everyone to see.
So allow me to show you some of
the teachers and students past
who have come through this space
and virtually through CS50.
CS50 is as much a community
as it is a course.
And indeed these are
just a few photographs
that have been shared with some
of our teachers around the world.
Here are some of our students in
Miami Dade College proudly displaying
their CS50 certificates
at the end of the course.
Some of our students and teachers
here in Chile, here in London, here
in Burma, here in Bolivia, here
in Nicaragua, here in Congo, here
in Pakistan, here in Egypt,
here in Ukraine, here
in India, and in so many other
locations around the world.
Indeed in this session,
we'll spend some time
focusing not only on CS50 the
curriculum but also CS50 the community.
And in fact, now that we've put
everyone's hands down temporarily,
might one or more of you be comfortable
unmoving yourself in just a moment
and saying hello and where
you're from and what you teach,
if you've taught before?
Would anyone like to raise their blue
hand and say hello to the world here?
Any blue hands?
Let's see.
Alison, can we call on you first?
Alison to say where in the world
you are and what you teach and hello
to all of the other teachers here.
ALISON: Hi, I'm from Florida and
I teach eighth grade IB Science.
and I'm going to be teaching
computer science this year.
The first year our school
has offered computer science.
DAVID J. MALAN: Wonderful.
Well, so glad you've joined us.
And indeed, per that first photo,
we've had this wonderful collaboration
with some of our students and
teachers and in Miami Dade
and in turn some of the
nearby high schools as well.
So welcome.
Let's go to someone else now.
Could we go to say John?
If you'd like to say hello and where
you're from and what you teach.
JOHN: Hi, I'm John from New York.
I work for the federal government, and
I'm interested in bringing CS50 inside.
So hopefully, this will
be a great experience.
I personally greatly
enjoyed CS50 myself,
and I think it can be a
great tool for expanding
computer science in the government.
DAVID J. MALAN: Wonderful.
So glad to have you with us as well.
Welcome.
How about one or two final hellos here?
Can we go to Augustine?
Augustine, if you would like to
say hello and where you're from
and what you're teaching.
I hope I'm pronouncing your name right.
AUGUSTINE: Yeah, you're
pronouncing it right.
I'm Augusting Coruvius.
I'm from Santiago, Chile.
I'm an undergraduate
student that is trying
to teach computer
science to other students
and also take my university
to modernize their CS courses.
DAVID J. MALAN: Oh, that's great.
So glad to have you as well.
The photograph I showed
briefly earlier from London
was actually from a student group
there that was indeed teaching CS50
to some of their classmates.
And lastly, can we say
a quick hello to Islam?
If you'd like to say hello where
you're from and what you teach.
DAVID: Hello.
I'm David Armstrong from Egypt.
DAVID J. MALAN: Nice to meet you.
And what do you teach now or what
are you considering teaching?
DAVID: I'm considering teaching
CS50 in my organization [INAUDIBLE]..
DAVID J. MALAN: So glad to
have you with us as well.
Well, allow me to give you all a
taste of what we'll be doing today
and in turn over the coming days too.
Here is a look at the schedule.
We'll begin today with the
session on teaching CS50x itself,
providing you with an overview
of curricular resources.
This will be followed
tomorrow and the next day
and into next week with sessions on
CS50's tools for submitting and grading
and also what they are
and how to use them.
We'll focus in particular on
grading assignments and handling
issues of academic honesty, taking
a look again at some of the tools
we provide and workflows
that teachers have
found helpful in their own classrooms
to use, if not some of CS50's own tools.
We'll focus on writing assessments too.
In addition to the problem sets
and quizzes and tests that CS50
itself provides, a lot of teachers,
particularly those at the high school
or middle school level that
meet with their students
more frequently than
university classrooms might,
like to write some of
their own assessments,
whether it's homework or
quizzes or tests or problems
and we'll give you a sense
of what you can do then.
And then the following week
will focus not only on CS50
but on some of the precursor
and follow on courses that you
can teach as well as take nowadays.
The first being a trio of courses
on computer science for business
professionals, CS50 for lawyers, and
understanding technology for anyone.
And we'll introduce you
through those curricula,
so that you can consider
whether offering portions
of those courses in your own classroom
or offering the whole course itself
before CS50, or to other
audiences of students that
might not want to take CS50x itself.
And then in the days that
follow, we'll introduce you
by way of CS50's with
his own Colton Ogden
to CS50's introduction to game
developments using 2D and 3D games.
We'll introduce you to
CS50's own Brian Yum
and in turn web programming
with Python and JavaScript,
as well as our most recent course
from Brian, artificial intelligence.
So that's all that lies
ahead, but we thought
we would begin today and see if we
can't engender some of the community.
On the screen here is a cohort of
teachers that a few years ago were
standing right here
on this stage where I
am when we used to hold this
workshop in person in Cambridge,
as well as in other
cities around the world.
Right now of course, circumstances don't
allow, but we do hope this finds you
and your family and friends and
colleagues quite well and healthy
albeit from afar.
But we'd like you to have an opportunity
to still meet some fellow educators
today and the days to come.
So in just a moment, you're going
to see a prompt on your screen
inviting you to a breakout group.
What we're going to do is
spend maybe five or so minutes
breaking out into smaller groups.
And allow me to invite you
by way of your breakout group
to say hello to your fellow teachers and
answer three questions for each other.
One, who and where are you in the world.
And in turn, what might you
be teaching this coming year.
Two, what are you excited about.
And three, what are you nervous about?
Odds are if you're excited about
something, so are other people.
And odds are even more so if
you're nervous about something,
especially if you've never taught
before or taught computer science
before, odds are you're nervous
about something as well.
And all the better if we can share
those emotions swirling around
in everyone's head to reinforce
the notion that indeed we're
all in this together as
one grander community.
So in just a moment, you're
about to see a prompt.
And we will see you
again in five minutes.
But please consider
turning on your video
and microphones for
these breakout groups
to say hello to your group of teachers.
See you in five minutes.
All right.
We are back.
So hopefully you had an opportunity
to connect with one or more teachers
in your breakout room.
Here on out, please feel
free to use the chat window
to communicate with each other, to share
URLs of relevant resources or the like.
You can also try using it for questions.
And Brian will kindly keep an eye
on it and see if he can't verbally
relay some questions to me.
But again, please forgive me if we
can't quite get to everything today.
We'll provide you with contact
information at the end of this session
as well.
The slides now that I'm using, in
case I go too quickly on any of it,
and so that you don't have
to scribble everything down,
Brian is going to go ahead and
share the URL of those slides
if you would like to
follow along on your ends.
That way you can keep a copy.
But allow me to forge ahead now with
an overview of what CS50x is itself
with an overview of curricular
resources so that you, as a teacher
can get a sense of what is available
to you and how you might use it.
At any point, if you have
a question, please do
feel free to raise your
blue digital hands.
And I'll do my best to call on
folks as we go via those hands.
All right.
So without further ado, what is what?
So odds are you've heard me
and others, say CS50 and CS50x,
what are these two
acronyms actually refer to?
So CS50 is Harvard
university's introduction
to the intellectual
enterprises of computer science
and the art of programming, an
undergraduate class for majors and non
majors here at Harvard that
takes place at most every fall
in this beautiful space here on campus.
It happens to be Harvard's largest class
with some 800 students here on campus.
Each year, we also have
200 to 300 students
who are taking the course
through Harvard's division
to continuing education
or extension school,
either adults or younger students
who are taking the course
for their own edification or in
pursuit of their own degree programs
and certificates.
And then we also have a cohort
of some 200 to 300 students
down the road in New Haven,
Connecticut at a university
called Yale with whom we've been
collaborating for some time.
So CS50, beyond being in this
introduction to computer science,
is also characterized by I think
three principles to which we've
adhered over the past many years.
One and first and foremost
is its accessibility.
Even though CS50 at the end of
the day is a good amount of work
for most students as well
as for most teachers,
it really is designed to be accessible.
And by accessible, we don't mean
easy or light load, but rather
a course that can be taken by students
who have never programmed before
and have never studied
computer science before.
It does of course have
a decent slope, such
that if you're starting here with no
prior background, some weeks later
you do exit the course with
a huge amount of background.
But the onboarding
for students is indeed
meant to be accessible to
anyone, whether or not they
have studied computer science before.
With that said, the course
is characterized deliberately
by its rigor, by its
workload, by the challenge,
that is its problem sets
are homework assignments.
But the goal there is
to ensure that students
have an immersive intensive
but hopefully rewarding
experience by the end of the semester.
So that either one, they can
go off into their own fields,
whether it's in the arts or
humanities, social sciences
or sciences, or real morals more
general and potentially never take
formally another computer
science course again,
but still be able to successfully
apply principles of computer science
and programming to problems
of interest to them.
Alternatively for students
who want to go on and pursue
additional studies in computer
science and program more frequently,
the course is also meant
to provide students
with a foundation in studies
and computer science,
particularly if they might
want to go off and major in
or pursue certificates in
computer science as well.
But ultimately, as mentioned, CS50 is
as much a course as it is a community.
And I daresay we focused fairly
unusually, both here on campus
and nowadays around the world, on truly
building up a community of teachers
and students alike.
And that community is characterized by
events, by certain cultural traditions,
by certain rubber ducks,
even, and the like so
that students and teachers alike
ultimately feel part of something
special.
They feel part of a collective
shared experience and not,
we hope, a more ordinary
course, if you will.
Now what is CS50x?
CS50x is the free OpenCourseWare
version of that very same course.
CS50 at Harvard is
identical curricularly
and technologically to CS50x.
CS50x is simply what we call
the free OpenCourseWare version
that you can find here at this
URL on Harvard's own website,
as well as on edX and other platforms
like YouTube, iTunes U, and the like.
So what is included?
If you are a teacher considering
adopting or adapting CS50x
in some form by way of all of
those OpenCourseWare materials,
well allow us to break it down
into three primary categories--
the content that's available
to you as a teacher,
the software that's available
to you as a teacher,
and the events that are available to
you as traditions as a teacher as well.
And with all of these
categories, realize
that the goal is not
for you as a teacher
to simply take necessarily
some course off the shelf
and redeliver it exactly as we
do here, but rather, indeed,
to adopt the class in that way
or adapt the class in that way,
doing what you feel is
best for your own students,
treating the course as material is
really as a menu of possibilities
that you can then incorporate
into your own class
or you can use yourself as training
for your own classroom environment.
Indeed, many teachers
who have never taught
computer science or, for instance,
CS50 itself have a wonderful resource
and that you can take the course
for free via OpenCourseWare
or edX or the like, and just
like here on campus where
we train our own teaching fellows
or teaching assistants effectively
by having them take
the course before they
then start to teach the
course to their classmates.
So can you as a teacher,
especially feeling
very uncomfortable or completely
uncomfortable right now,
spend the coming months taking the class
via OpenCourseWare or edX or the like,
and that is hands down the best way
to prepare yourself for teaching it
in some form in your own class.
So what, then, is included
in the way of content?
Well, generally speaking,
we categorize the content
along the lines of
what we call lectures,
which are more conceptually-oriented
talks given by me
here in Sanders Theatre on
campus that we then film and make
freely available online; sections,
which are small-scale classrooms led
by our courses teaching fellows or
teaching assistants, who themselves are
usually students who have taken
the course one or more years prior
and are now sufficiently
comfortable teaching it
to peers or classmates of their own.
We also make available
what are called shorts--
literally short videos that
supplement these longer-form lectures
that focus on individual topics, led
most recently by CS50's zone Doug
Lloyd, and then ultimately,
what really characterizes
students' experience in CS50 is its
problem sets or homework assignments
or really programming
projects, each of which
is generally accompanied by a
so-called walkthrough which is a video
most recently led by
CS50's own Brian Yu, which
offers step-by-step instructions for
just getting started with a problem,
and are designed to answer
the frequently-asked question,
where do I even begin?
So just as we use lectures
to present concepts
and we use sections to reinforce
and explore concepts in more detail,
walkthroughs are specifically focused
on the problem sets themselves
and helping students succeed
in implementing those.
And then we here on campus have what we
call quizzes and a test each semester.
The quizzes are meant
to be opportunities
not just to assess whether or
not the student understands
the material, but also opportunities
to teach additional material
beyond the course's own lecture.
So for instance, here
typically at Harvard,
we'll have lecture live in person
on a Monday that we also then film,
and we ask students to submit a quiz--
two or three questions via a form
online before their next class
meeting, their so-called sections
with the teaching fellows.
So how might teachers be outside of
Harvard use these same materials?
They might have their students
watch CS50's lecture online,
then they might assign one
or more of these quizzes
or tests at different
points during the semester
to, again, reinforce material, but
also introduce new material as well.
But toward the end of
this session, where
we focus on exactly how you
can build your own blocks out
of these various components.
So what is covered in the way of
lectures and sections in particular?
Well if you've taken CS50, odds
are, most of these concepts
are already familiar to
you, and if not, here's
a high level overview of what's
covered in CS50, and in turn, CS50x.
We begin this semester with a look
at Scratch, a graphical programming
language where you program by
dragging and dropping puzzle pieces,
among the goals of which is to first
introduce students to principles
of procedural programming, so to
speak, common programming paradigms,
but also to give them
an opportunity very
early on to create something,
create something that's visual
and audio that they can even share with
their classmates or family or friends.
We then follow that by
an introduction to C,
an older, more traditional
text-based language on
top of which many of today's
languages are, in effect, built.
And we introduce students
thereafter to concepts like arrays,
how can you begin to organize
information inside of that computer?
We focus on algorithms, how can
you organize, search, and sort
information via computer
efficiently step by step?
Then we focus unusually
in CS50 on memory itself,
and that's an opportunity
opened up to us
because we are using a language
like C which gives you,
for better or for worse, very
low-level control over what
is going on inside of that computer.
And indeed, we introduce
students to pointers and memory
allocation and the like,
and in turn, quite a few seg
faults or segmentation
faults, but that's
among the challenges for students.
We introduce students
ultimately in this portion
of the course to data structures.
How can you layout information
more efficiently in memory
so as to solve problems ever
more effectively and efficiently?
And then mid-semester we
begin to transition away
from C to a more modern language
called Python, very popular
in applications of command
line programming, web
programming, and the like these days.
And by way of Python do we revisit
some of the very same programs
that students implemented
early on in this semester,
but we have them re-implement
the C code now in Python.
But we don't stop there.
We then introduce students to
principles of web programming,
and we introduce them to a bit of
SQL and HTML and CSS and JavaScript,
and via that collection of
technologies do students ultimately
make user interfaces
and develop applications
that are so much more familiar to
them today via web browser or phone
than, for instance, the simple
black and white window in which we
begin the semester by
way of terminal windows.
And then there are other
materials available to you
by way of CS50's with
these other courses,
but we'll touch on those again in the
coming weeks as to other ingredients
that you might pull
off the shelf and weave
into your classroom's environment.
But what about now these shorts?
So the shorts, again, are shorter-form
videos filmed by CS50's his own Doug
Lloyd that focus on specific topics
like functions or memory allocation
or sorting or searching or any
number of other topics as well.
And so here is a fairly long list
of all of the additional shorts that
are available to you as
a teacher that either you
as a teacher can use to better
understand the material yourself
or that you can assign
to students in order
for them to better
understand that material.
And the same goes for
CS50's lectures as well.
You as a teacher can indeed adopt CS50
outright and provide your students
with the lectures that I
happened to lead here in Sanders
and have them watch those
lectures early on each week,
and then you in your own
classroom can certainly
use your in-person, your more valuable
time with the students physically
to actually explore that material
in more detail, to answer questions
that they might have, if I didn't
explain something particularly well
or they'd like to hear it from another
perspective, or most compellingly,
perhaps to do a lot of
hands-on activities together
or to even work on the course's
problem sets as a group.
And the sections to which
I allude to here on campus,
they're typically led by our teaching
fellows or teaching assistants,
but yeah, beyond Cambridge,
those same materials
are very often used by teachers
perhaps such as yourselves
because they are simply
additional materials that
go into more detail on certain topics,
provide you with sample programs
that you can implement
with your students.
So one model, too, might be to have
students watch CS50's lectures online
at some point during the
week, and then in person,
use our section materials
in your own classroom
to cover that material in
more detail at greater depth.
Or alternatively, if you'd
rather not use CS50's lectures
at all, that, too, is quite
fine, you as the teacher
are welcome to watch
them behind the scenes
if only for reference or
not at all, and then you
yourself can present CS50's curriculum
and its concepts in your own classroom
without ever mentioning or
showing to your students
these lectures that we filmed here.
It's entirely up to you whether
you adopt the class outright
or you adapt the class, so
to speak, in a way that's
more conducive for your students.
We make the materials
available to you to execute
on however you see fit, whether
the lectures, the sections, or now
the shorts.
Now as for the problem
sets and walkthroughs,
these are, again, what
primarily characterize
students' experience in taking
CS50 whether it's here at Harvard
or anywhere around the world.
The problem sets are
by design meant to be
more project-oriented than
typical homework assignments.
I personally have never been a
fan of the sort of end-of-chapter
in a textbook-style problems
that are very simplistic
and only have students write
a few lines of code that
really aren't that interesting even if
they help the student better understand
the syntax of the language itself.
CS50's problem sets, by contrast, are
an opportunity for students via Scratch
and then C and then Python
and then SQL and then more
to explore real-world problems, to
solve problems and implement programs
in ways that use principles of
computer science, but with effects
that hopefully inspire and excite them
about the field and its possibilities
for themselves.
So for instance, although we do
start this semester quite quickly
with Scratch, we then
transition again to C
and have students implement, for
instance, their own greedy algorithm.
For instance, if you walk into a store,
you hand someone some amount of money
and they owe you some change, via
what algorithm can you figure out
the fewest number of coins to give that
customer back so that you've minimized
just how many coins you're
taking out of your cash register
and giving to that customer?
Cryptography, we introduced
this to students very early on,
and we have them implement their own
ciphers or algorithms for encrypting
and decrypting information.
We then introduced students to the world
of elections, very much in vogue right
now in the US as well as in
other countries around the world,
but we ask students to consider,
what are the right algorithms
for conducting those human elections?
It's quite common to just expect a
majority vote or perhaps a plurality
vote, but there's
actually other algorithms,
and different algorithms can
influence who wins an election.
And so we ask students to
implement some of these algorithms
and explore those disparate
algorithms via their own code.
We introduce students to the world of
forensics and images more generally.
We have them recover deleted images
from a digital camera's memory card,
for instance, and recover
some actual JPEGs.
We have them implement a number
of Instagram-like filters
such that they can take
a photo of their very own
and make it black and
white or sepia or invert it
or do other transformations just
like on Instagram, Snapchat, and the
like these days.
We then introduce students
ultimately to SQL,
on language particularly
well-suited to large data sets,
and we have them explore the Internet
Movie Database of TV shows and movies
and perform queries representative
of how they might solve problems
with other large data sets in the
world, and then towards semester's end
do we additionally focus on
the world of web programming
and have students implement, for
instance, their own stock-like trading
website with virtual currency that's
such that they can buy and sell stocks
by interacting with a real world API
or Application Programming Interface.
And there's even more problems
that we don't typically
offer in a given year of CS50
because there's simply not time,
but all of them are available
to you such as those on the list
here as a teacher if you might want
to integrate them into your own class,
particularly if you have
more in-person class time
than a university environment
might have day to day.
And then when it comes to the
course's quizzes and tests,
these are not part of CS50x
students might take online,
we typically use these only
on campus and we provide them
to teachers in their
own environments, again,
because they're meant to go beyond
the scope sometimes of CS50,
but also be summative
assessments that teachers
can use to make sure their students
are mastering the material.
So here is just a list of
some of last year's problems,
and they introduce students often to
current events or other technologies
that we don't cover in CS50
itself, but these and more
are available to you as teachers
as well as sample solutions,
so that if you yourself aren't quite
sure what's expected in a problem,
you can prepare comfortably
for your own classes as well.
So all of this is ultimately made
available in so-called OpenCourseWare,
freely available material that you
can download from CS50's website
as well as from other
resources we'll provide to you.
And again, the theme
ultimately is up to you--
whether to adopt the class
outright or adapt it.
So what a particularly new
teacher might do initially
if teaching CS50 or computer science for
the very first time is adapt the class.
Have their students at the start
of the week or the start of a month
watch one of CS50's lectures.
And then if that teacher
is able in ordinary times
to meet with their students in person
in a classroom or other environment,
to then walk through that
material in more detail,
to answer questions that they might
have as a result of the material,
to do more hands-on activities,
and those activities
can come from our lecture or those
so-called section materials as well.
And then you can assign at your pace
the courses quizzes and problem sets
and tests or only a subset thereof.
Alternatively if you've been teaching
computer science or CS50 for some time
and you really just want to be
inspired by freely available materials
and weave them into your
course using literally
your own voice and your own
pedagogical style, that, too, is fine.
And so that might be said to adapt
to the class, where students do not
need to watch these lectures or any
of our shorts or other materials,
perhaps you use those for
yourself only or not at all,
and you rely on your own classroom time
to introduce students to a phone book
that you might tear in half in
person, or your own students,
move them around on stage
or in front of the classroom
so as to practice searching and
sorting and other algorithms.
So it's a very common
paradigm for teachers
maybe initially to adopt CS50,
but then eventually adapt it.
Once you yourself feel
comfortable, have your footing,
and decide that you would like to
do things differently or better
or in a manner more
conducive to your students,
that, too, l is ultimately fine.
So let me give you a sense, then, of
how these materials are made available,
and we'll, of course,
follow up with more
specific URLs and the like beyond
what's in these slides here today.
So if you're familiar with
CS50's OpenCourseWare website,
you'll see that many of the pages
are formatted a little like this.
So for instance, for a
typical week of CS50,
we make available the lecture
itself, which is typically
about two hours of content taught by me
here in Sanders Theatre to a roomful,
in ordinary years, of students in which
we introduce students to concepts.
Those materials are made available
in any number of formats.
So audio formats, if you
want to download or listen
to an MP3 on some device.
We have one of our teaching
fellows or TFs take notes
so that our own students
and you and your students
don't have to be scribbling down
everything I say or perhaps you say,
we have a canonal set
of notes that summarize
what was covered in that lecture
so that students can especially
search it and find material
that might be available to them.
We also make available the
course's slides, not only
as one PD PDFs that I use here in
Sanders, but also as Google Slides.
If you want to just copy or adapt
one or more of those slides,
you can make a copy of the Google
Slides and edit them or translate them
into your own spoken
language as you see fit.
We make available source code.
So any of the programs
I write here in class,
we make available as a big listing
or index of all of those files,
as well as the zip file,
and then even a PDF.
In fact, if you've ever
watched some of CS50's lectures
and you've seen me
futz with some papers,
those are usually printouts of
the code that I intend to write.
So sometimes I still screw up even
though I have that printed paper there
for me, but it's a handy resource
so that you can live code
but fall back on if you're
feeling a little stressed
or under pressure to figure out
what you might have done wrong.
And then of course, the videos.
And these videos are made available
formats and different resolutions
and bandwidths, one
via CS50's video player
which has a number of features
we'll give you a sense of and a bit,
MP4s, which is a popular
downloadable format for video
that you can download
in very small files,
like 360p, which is of pretty small
resolution, a couple of megabytes
maximally, which is good for
students on slow internet connections
or intermittent or expensive
internet connections, all the way
up to MP4s that are 4K resolution that
you can even watch on a sofa in front
of a TV at home as well.
And then, of course, via YouTube are
those same videos all accessible, too,
assuming YouTube itself is not
blocked in the country you're in.
And then the shorts, too.
They're made available not only as
MP4s, but also via CS50's video player
or YouTube as well.
The picture here are just a few sample
shorts from this particular week.
And then last but not least
is the course's problem set.
We organized CS50's
homework here at Harvard
in two problem sets, which means
one or more problems we assign
to students per week or at a time.
Elsewhere in the world when folks have
adopted CS50 for their own classroom,
they might not assign whole
problem sets unless you want
to follow our curriculum week by week.
Rather, they might take
apart a problem set
and assign students one problem
per week, or maybe one or two.
Maybe they'll do some
of the problems in class
and have their students do it at home.
It is entirely up to you, we make
all of the individual problems
available to you as teachers.
What about now software?
So I alluded first and
foremost to CS50's video player
via which you and students can
access the course's content
if not by YouTube or downloadable MP4s.
Just to give you a sense, though, of
what CS50's own video player does,
it adds a few features that
are pedagogically motivated.
So for instance, here is
an awkward screenshot of me
in one of CS50's
lectures this past year.
And if we focus along the
top-right of the screen,
you'll see a menu bar
with a few options.
The first of those options
it says here are chapters.
So what we do is go through
each of the lectures thanks
to one of the course's teaching
fellows and decide what time code--
hour and minute and second--
I began introducing a particular
topic so that you the teacher
or they the students can jump to
specific parts of the lecture,
especially if you don't need
or want your students watching
two-hour lectures at
a time, you only want
them to watch small
portions of them or you
yourself only small portions
thereof, these chapters
can help you navigate the content.
We also have captions in English.
So these are human-transcribed
captions, not Google automation,
and these captions can also be searched.
So for better or for worse, every
word that comes out of my mouth
is jotted down here
as text so that if you
want as a student or teacher to find
where we discussed binary search,
you can start typing binary
into the search field,
and voila, you'll see every time
code at which I mentioned binary
in that particular class.
There's also keyboard shortcuts as
well as most recently a menu of snacks.
It has been commented
more than once online
that it's unfortunate that even though
here at Harvard we take breaks roughly
in the middle of these lectures and go
outside and have snacks, whether it's
some cake at the beginning of the
semester or some vegetables or fruits
later in the semester for health's sake,
those are now available in emoji form
to anyone who might want to click on
those while watching a video as well.
Meanwhile, perhaps the most
compelling pedagogical feature
of CS50's video player is this one here.
Of course, if I'm standing
in front of a screen onstage,
I might look as before like this such
that it's not quite easy for students
to see what's on the screen behind me.
And so in the top left-hand
corner of CS50's video player
is a screen toggle that
allows them to zoom in
on exactly what was on my
laptop at that moment in time,
and they can stay on
that view until they'd
like to toggle back to
whatever is going on onstage.
So collectively, those
feature's chapters and captions
and snacks and screen compose
what is CS50's own video player.
As for the programming tools
that CS50 students will use
is that known first as CS50 Sandbox.
And allow me to disclaim that over
the course of this summer and fall,
the user interfaces of the tools
you're about to see will odds
are look a little bit different
as they merge into one tool,
but the functionality
you're about to see
will remain available even
as the appearance changes.
So CS50 Sandbox is meant to
be a very simple programming
environment that allows students
to get started programming quickly.
Those of you might know, if you deal
with Macs or PCs or computer labs
in a classroom environment,
it can be a challenge
to have the IT team install special
software on any of the computers,
it's a challenge sometimes for students
to download, install, and configure
any particular tools for
a programming environment.
So everything that CS50
does is available for free
via web-based technologies
via the so-called cloud.
And indeed, CS50 Sandbox is a
web-based programming environment
that is screenshotted here.
You can play if you go to
sandbox.cs50.io, if Brian wouldn't
mind pasting that into the chat.
It requires only a free
GitHub account to log in.
And CS50 Sandbox per the
checkboxes here allows
you to create a very literally simple
programming environment quite quickly.
And it will provide students along
the top with tabs for their code,
and along the bottom with
an actual terminal window.
And this is very much a
pedagogical decision of the class.
You might be familiar with
other environments that
allow students to compile and execute
code just by clicking a button,
like a Play button, whether
that's an Xcode or Eclipse
or NetBeans or the like, we very
deliberately pedagogically introduce
students very early on to an actual
terminal window, which while it might
look like a dated technology, is
incredibly powerful and also very much
in use and in vogue
in the real world when
it comes to programming in
any number of languages.
And so we don't hide this
particular implementation detail
from students, but rather
per this screenshot,
we have them make or compile
their code and then run it
without initially the more
familiar buttons in windows
and tabs and the like, those
come back later in the course.
Besides CS50 Sandbox do we
have a tool called CS50 Lab.
CS50 Lab is essentially CS50
Sandbox plus integrated instructions
for the student.
So if you've ever seen a tool
like Codecademy or the like,
you know that there are these
web-based programming environments that
have instructions along
one side, the programming
environments along the other, but
generally speaking, those systems
are proprietary in the sense that you
need to sign up for or pay for or use
their particular interface or the like.
CS50 Lab is available to teachers
simply by having a free GitHub account
and by knowing a little bit of
Markdown, which is a text-based markup
language even simpler than
HTML, and a little bit of YAML,
which is a configuration file format.
Together with Markdown and YAML can
you actually create your own CS50 Lab.
So we have some of our own,
we assign those to students,
and make them available
to you as teachers
to assign to your own students, but some
of our own teachers have on their own
created their own repository
or folder on GitHub,
and they've written up their own
homework problems or homework
assignments using CS50 Lab.
What they ultimate
create is an interface
that looks a little something like
this where you have something that
looks quite like the
sandbox along one side,
but then you have a fairly
user-friendly window of instructions.
And that ultimately is HTML,
but they're written again
in this lightweight format
called Markdown, even
including images or anything else.
So in a nutshell and in a later
session during this workshop
this week, we'll provide you
with a more hands-on look
at how you can create
your own CS50 Lab simply
by having a GitHub repository to them.
We then take care of the process of
creating the programming environment,
turning the Markdown into HTML,
and presenting it to your students,
but you ultimately author the content
of those labs if you would like.
But lastly when it comes
to programming environments
is CS50's most powerful tool called
CS50 IDE, built atop another cloud
service called Cloud9.
CS50 IDE is essentially
a set of plugins that
are educationally
motivated that simplify
that real-world web programming
environment known as Cloud9.
And so for instance, here is
a screenshot of CS50's IDE.
It, too, has tabbed windows where
students can write their code,
whether it's in C or Python or frankly
C++ or Java or other languages are
supported as well even if we
don't use them in CS50 itself.
Along the bottom again
is a built-in terminal
window that provide students with
command line access to their code
and commands.
And then a file browser along
the side where they can also
see a graphical user interface to
navigate all of the files and folders
that they might have.
But there are other
features as well, including
a built-in debugger that allows students
to navigate their code step by step.
It's based on something called GDB,
but it doesn't use the command line
with purely text output, it's
graphical, similar in spirit
to Visual Studio or Eclipse or
NetBeans and the like so students
can set so-called breakpoints in
their code and walk through it
step by step by step.
The IDE also has collaboration built in.
Students can share their
workspaces with you, their teacher,
so that you can log in and
see their code in situ,
or you can even chat
textually back and forth
with the student if providing them help
remotely, especially nowadays if all
of us are going to be working
from home for some time,
if your school doesn't reopen yet,
you can collaborate with your students
and provide them with
guidance interactively,
and if you'd like to introduce
pair programming to your students
where two students work on
a program at the same time,
one student can share
their IDE with another,
and so long as both
have GitHub accounts,
they can together work on some program
and even chat within the IDE itself.
There's also revision history built in.
So students can certainly
use Git or SVN or Mercurial
if you're familiar with these
version control programs,
but they can also just let the
IDE automatically save and backup
their code, and then with a little
slider that they move left to right,
they can rewind in time if they want
to go back to an earlier version,
or if God forbid they mess
up or delete something,
the code will be automatically
backed up for them.
And so that, then, is CS50
IDE, and later this week,
well CS50's own Kareem Zidane, who
developed a lot of this functionality,
introduce us in more detail
to this tool and others.
Now there's a few other tools
that are available as part
of the toolkit for you that you can
use with or without CS50 itself.
CS50 Render at render.cs50.io, if
Brian wouldn't mind pasting that URL.
It's a tool that just makes it easy
to drag and drop or upload source code
in C, in Python, Java, C++, whatever
language you teach for any class,
and it just turns them into a nice PDF
for you such that it's oriented like
this landscape mode, its
syntax highlighted in color.
So again, if you've ever seen me
with some papers off to the side
in CS50 itself, I'm
usually looking at code
that I've printed out
for myself in advance.
However, years ago, we used to use
the same PDFs to provide comments
on a student's work.
So we'll talk later this
week, too, about assessments
and with some of CS50's own teachers
around the world where we introduce you
to some workflows that you yourself
could consider adopting to provide
students with feedback on their code.
We have tools, like
check50 and style50--
more on those later this week--
via which your students can get
automated feedback on their code,
but if you'd like to also critique
and provide students with feedback
on the design of their programs, you
can use something as simple as PDFs
and then use Acrobat or Apple
Preview or any other tool
to type human comments on
their code as well in hopes
of helping them write better code.
And you can even line
up code side by side
if you want to compare, for
instance, the C version of something
to the Python version or the like.
But lastly does CS50 have this
tradition of community events
here on campus as well
as around the world.
So each year at the very
start of the semester
do we begin CS50 itself
with CS50 Puzzle Day,
and this is an opportunity
for students on campus
who are taking or maybe not even taking
CS50 to gather here on a Saturday
afternoon for a few
hours with some pizza
and literally a printed
packet of puzzles.
None of those puzzles require prior
CS experience or any programming
experience.
Students can bring laptops, but
they won't be writing any code,
but they might use Google or other
resources to help figure out clues.
And these puzzles, ultimately,
are all about problem-solving,
and we very deliberately educationally
start the semester with CS50 Puzzle Day
so that students have an opportunity
to realize that computer science is not
about programming at the end of the day.
It's absolutely useful
and powerful tool that
is very often learned along the
way when studying computer science,
but it's not necessarily
an end unto itself.
Rather, it's a tool one uses to
solve problems more generally.
And so CS50 Puzzle Day challenges
students on small teams to get together
and really for fun competitively try
to solve more puzzles more quickly
than other teams of classmates
that might have been formed.
And we often take photographs
or video footage of these events
just to share in the memories
with future students,
and indeed, just a few
photos from years past
might be these here of our own
CS50 Puzzle Day around the world.
So we have for many years
now made these same puzzles
available to teachers like yourself
and student groups around the world
so that they can organize their own
puzzle days in person, in school,
in cafes, in libraries, at home, or
nowadays especially online via Zoom
or Skype or some similar technology.
And so here are just a few of
the smiling faces either before
or after having solved
a whole lot of puzzles
from folks around the world who kindly
took these photographs after forming
their own communities
and getting together
for some afternoon or evening
of puzzle solving on their own.
This past spring, you might recall that
we organized CS50x Puzzle Day online,
but if and when you're able to
reunite with your students in person,
you can certainly do this in person,
or perhaps in the coming months,
you can do this online as well.
We'll follow up and provide
you with the packet of puzzles
if you'd like to hold it
locally somehow in some form.
Now the CS50 Hackathon is
another tradition of ours
that we've been doing for
quite a few years now,
and it's meant to be an
opportunity for students to have,
in our case, an incredibly
immersive and hopefully memorable
academic experience focused on the
creation of their final project.
In addition to CS50's
problem sets, the course
culminates in a capstone,
of sorts, a final project,
and a final project
is essentially a piece
of software-- maybe a web application,
a command line tool, a Chrome extension,
a mobile application-- that students
design and implement on their own.
I and the course's teaching fellows
provide students with feedback,
and we help them calibrate their
project so that it's not too easy
and it's not too hard, it's not too
little work, it's not too much work,
but ultimately students implement
the final project themselves
without a specification
or problem set from us.
And the Hackathon is an opportunity
toward the end of our school year where
we get together-- in our case,
at 7:00 PM in the evening,
and we go until 7:00 AM in the morning--
12 hours-- of working
collaboratively with classmates
alongside you on some
project of meaning to you.
Now that's not appealing for everyone
to get together at 7:00 PM at night
and just keep working till
7:00 AM in the morning,
and so we've adapted
this event all over.
And indeed, at the middle
school or high school level,
we've often encouraged folks or
visited folks hosting these events more
in the morning or in the afternoon.
You, of course, in your own locale
can implement this vision however
you see fit, and here, too, we have
some photographs from CS50x communities
around the world that have held
their own CS50x Puzzle Days
and also CS50 Hackathons focused
either on these final projects,
or if they so choose, focused
as well on simply problem sets.
So especially if you want to
hold events like this mid-year,
you can instead use CS50's
Hackathon to simply bring students
together on some afternoon or
morning or evening or weekend
to focus on one or more problems
that they've been assigned.
Taking photographs and photobooths
and the like are part of the tradition
as well, and so those are just a
few of the photos you've seen there.
And then last but certainly
not least is truly
the capstone experience for students
in the class the so-called CS50 Fair.
This is an event borne of really
our own experience some years ago
where at the end of CS50
itself here at Harvard,
we used to break the students
up into small groups--
their sections, so to speak--
and each of these students
in those sections,
working either on their
own on a final project
or with one or two other classmates,
would present their final projects
in a small classroom to
their teaching fellow
and maybe 10 or 20 other classmates.
And it was an opportunity for
them to present their projects,
see what everyone else
did, but it wasn't
a particularly exciting
or inspiring environment,
and really, everyone was generally
going through the motions.
It was something you had to
do at the end of the day,
and it really wasn't an
opportunity to celebrate
what it is everyone had accomplished.
And so the CS50 Fair, by contrast
now, has an end-of-year event that we
hold here at Harvard, we
hold in New Haven at Yale,
and we encourage teachers around the
world to hold online or on campus
as well for their own students.
And it's an opportunity for the students
to bring their laptops or desktops
or borrow one and the same to
stand it up on a desk like this
and then invite the rest of the school,
invite other students not taking CS50,
invite teachers, invite
staff, invite tourists
here in our case in Harvard
Square to just drop by
and chat up students and delight
in what it is they have built
and what it is they have accomplished.
So we often play music
in the background,
we invite friends from industry, there's
usually popcorn and candy and the like,
and the CS50 Fair ultimately
truly is an opportunity
for students to gather
around each other's computers
and look at what they've created and
accomplished on their screens here.
And we've encouraged
teachers around the world
to do these in their own classrooms,
in their own communities,
as well as in these cases, to send
us some photographs as well after.
And indeed, this was not obvious to
me years ago when I started teaching,
and we only have these photographs
because one of our own teaching fellows
10-plus years ago happened to be taking
photos at one of our very CS50 Fairs
when it occurred to me, wow, we should
actually be systematically remembering
to capture these kinds
of moments and memories
so that one, students have little
mementos or souvenirs from an otherwise
purely educational experience,
but one that is now all the more
community and collectively-oriented.
But two, having all of
these photos and videos,
as you might have seen from
CS50's own social media pages,
is a wonderful way to recruit other
students and to pique their curiosity
as to what their classmates have done,
especially since here at Harvard,
two-thirds--
66-plus percent of our students
have never taken a CS course before.
And indeed, there are many
more students out there
who have never studied CS than
who have studied computer science.
And so these photographs,
these videos, these events,
these memories are a
wonderful opportunity,
especially if you're a teacher--
the only teacher teaching
computer science,
trying to build up and start
a computer science program,
just capturing these memories, if
your students and their parents
perhaps are comfortable with
such, is a wonderful way
of reaching the eyes and ears
of students who might not even
consider themselves computer persons
until they're encouraged and invited
to join you and their classmates.
So for you as teachers, as well as
for all of CS50's online students,
we do have any number of
these online communities.
We have generally avoided creating
a walled garden, so to speak,
that for which you have
to sign up for CS50,
and we've instead tried to bring the
course to all different communities
and platforms out there.
And so this is most of CS50's
online communities here.
Again, via the chat
window, if Brian, you
wouldn't mind re-pasting the
link of these slides for anyone
who recently joined, all
of these are clickable
and you can visit them yourself to
turn to others either for questions
about material or even advice of
other educators for tips and tricks
from fellow teachers.
And then what else is available?
So you might know, too, at
the end of the semester,
we provide students with an opportunity
to receive a CS50 certificate,
and the CS50 certificate proclaims
that they have successfully
completed something like CS50x
or one of CS50's other classes.
What that tool also
has the ability to do
if you so choose is if you are
a teacher at a specific school
or a community or
student group or the like
and you would like to customize these
certificates for your own community,
we're happy to facilitate that as well.
So at the end of your school
year, if you reach out to us,
and provided your students have indeed
met the expectations for the course's
certificates and you'd
like us to customize it
with an explicit mention of your city
or country or school or the like,
we're happy to do that for teachers
as well so that you yourself
can present them perhaps
printed out on paper
when we're all back in person to your
students in person in recognition
of their accomplishments.
So how to find out more support and
stay in touch with each other and us,
we'll follow up by email with links
to all of these resources, too,
but moving forward,
there's an email list
that you'll be able to sign up for.
We'll send you an invitation to
teachers@lists.cs50.harvard.edu,
and this will be a list where you can
just ask questions of fellow teachers.
We have a separate list for
students, but the teacher list
is meant to be about advice
or ideas or inspiration
for your own classes, confusion that
you might want to ask of fellow teachers
but not necessarily of other students.
And so realize, this is one
resource available to you.
Allow me to say yet
again how nice it's been
to connect with so many people
here today around the world.
If you happened to tune
in late today and would
like to catch this session again, we'll
do so again at 10:00 PM Eastern Time
this evening.
Tomorrow will we focus all the
more on some of CS50's tools,
and CS50's own Kareem Zidane himself,
a former student from Egypt who is now
with us here at Harvard full-time
working on CS50 IDE and other software
projects, will lead teachers in a
more hands-on demonstration of several
of these tools, and then
later in the week will Brian
go into more depth on
grading and assessment,
and as will some of our
other teachers as well.
In the meantime, we'll follow
up late today or tomorrow
with an email with the links to the
slides and more, but so nice to see
everyone again.
If you'd like to perhaps wave goodbye
to everyone else here on the screen,
we're looking forward to
seeing everyone again tomorrow
and the days that follow.
This was CS50.
