The authors of the BJC curriculum think that computer programming is one of
the most satisfying of all human activities—it's generally fun (when
it's not frustrating because of a bug you can't find), but it's what Seymour
Papert called "hard fun," mind-stretching and, because the authority is the
computer rather than the teacher, a big change from jumping through hoops.
It's a game of skill, like chess, but
without the competitive aspect, and with useful results beyond the act of
programming itself. That's the best reason to study computer science, and we
want all kids, not just the ones who fit the nerd stereotype, to
experience our joy in programming.
We also think that computer programs (not just the pictures that programs
can produce) can be things of beauty. Yes, programs can also be ugly, if
they're long sequences of assignment statements with no structure. But good
programmers develop a sense of programming aesthetics. This is one reason why
it's so important to us to include recursion in the curriculum:
A recursive program can generate a complex, intricate computing process from a
very small piece of code, and we remember that revelation as the moment when
we discovered the beauty of programs.
It's not easy to preserve beauty and joy when translating a course taught
by its authors into a curriculum for widespread use. Too much scaffolding in
a project and the joy is gone; too little scaffolding and the student feels
helpless and incompetent. That's why the original authors from the University
of California, Berkeley, formed a partnership with the high school curriculum
experts at EDC (Education Development Center). Try the
curriculum to see how you think we did.
Computer Science Principles
The College Board
AP CS Principles
curriculum framework is organized around
seven "Big Ideas" (things to learn) and six "Computational Thinking Practices"
(things to do):
Every conforming curriculum must teach all of these, but curricula may
differ in the amount of emphasis given to each. (The slices in the pies aren't
really quantitative, just a suggestive snapshot of how BJC stands out.)
There is much overlap between the Ideas and the Practices. Creativity is
an Idea, but Creating is a Practice. Similarly, Abstraction is an Idea, but
Abstracting is a Practice. Think of the first pie as representing text in the
curriculum materials, and the second pie as representing how we expect
students to spend their time. The circles at the center of each pie indicate
that the idea of Programming and the practice of Creating are at the center
of BJC, and intersect with all the others.
First, the Big Ideas. BJC is proudly Programming-heavy. We
believe that Snap!, the programming language we use, allows us to reach
a diverse audience of beginners, who may initially not think they're
interested in programming, because it combines the ease of use of visual
programming with expressive power previously found only in the most
sophisticated text-based languages. (More on this below.) We go far beyond the CS Principles requirements,
featuring the advanced techniques of recursion and higher order functions.
We view Abstraction as the central idea of computer science,
and we emphasize the use of abstraction in the context of programming. This
includes both control abstraction to generalize programming patterns and data
abstraction to isolate the implementation of an abstract data type from its
Our secondary emphasis is on Global Impact, the social
implications of computing. We use readings and classroom discussion to
explore various aspects of this topic in each unit of the course.
Details of the topics and teaching goals are below.
Two of the remaining four topics are more implicit than explicit in our
approach. Students exercise Creativity in their programming
projects, but we don't talk about it to the same extent as the other
topics. Similarly, students develop Algorithms as they program,
but we don't often treat algorithms as a separate topic, except when we are
teaching about analysis of algorithms and asymptotic orders of growth.
The final category of topics, Data and the Internet, are
important and are covered thoroughly, but where possible our coverage takes
the form of programming activities rather than, for example, using commercial
Now, about the Practices: The phrase "Computational Artifacts" is
meant to encompass videos, slide decks, blogs, programs, music,
spreadsheets—anything you can create with a computer. Creating is, we
think, by far the most important of the Practices, but the most important
artifacts are computer programs! More precisely, if a student is writing a
game program, for example, there are two acts of creation happening at once.
The student is interested in making a game, and displays creativity in the
design of the game. But she creates the game by creating a program, and
also displays creativity in the design of the program structure.
And the latter is the real computer science.
Just as the idea of abstraction is central to, and inseparable from, the
idea of programming, the practice of abstraction is central to
programming. We constantly encourage students to use layers of abstraction to
structure a programming project.
"Connecting computing" can mean connecting it to hobbies, or connecting it
to industry, or to science. But most importantly, for us, students connect
computing to its social implications, our secondary focus.
Almost as important is the practice of analyzing programs: debugging,
predicting the behavior of someone else's code, and thinking about efficiency.
But we would emphasize that this skill is not an end in itself; it serves the
ultimate goal of creating programs that work. We're not nearly as interested
in analyzing "artifacts" other than programs.
The two remaining practices are important, but less emphasized in BJC.
Like most CSP curricula, we use pair programming, so students are constantly
talking with their partners and sharing the work. At the beginning of the
course we teach the process of pair programming, and in the discussion of
social implications of computing students have to communicate their ideas, but
communicating and collaborating aren't unique to computer science.
Snap!, the programming
language designed to support this course, starts with the Scratch design of drag-and-drop blocks
representing primitive capabilities. Scratch is routinely learned by
self-taught eight-year-olds, so it's not intimidating and has a very low
barrier to entry.. The blocks' shapes and colors remind users of
the block categories.
The C-shaped block is a loop, and visually encloses the code that should be
repeated. Green blocks are about drawing, and blue blocks are about motion.
But because Scratch was designed to be usable by eight-year-olds, its
designers left out some key capabilities for teaching computer science.
Snap! adds the needed abstraction capabilities, while preserving the
use of carefully designed visual metaphors to aid understanding:
• For control abstraction, Snap! users can build their own
blocks, including functions as well as action scripts.
This capability is essential to the Abstraction big idea, but it
also lets us teach recursion, through which a small program can
have a very complex result:
• Because Snap! blocks can take other blocks or scripts as
inputs, and because of the very simple notation used for anonymous functions,
we can teach the even more powerful control abstraction of higher order
This capability, first class procedures, makes Snap! more powerful
and expressive than most text-based programming languages. The visual
representation makes procedure as data seem concrete to students, as in this
list of procedures:
• Finally, because lists are first class data in Snap!, we
can build abstract data types and use them in larger data structures, such as
• For students who insist on programming in a text language,
(The picture shows a one-liner, but there is no limit to the length or
capability we can have our cake and eat it too, with respect to the
(pointless, we think) argument about block languages vs. text languages.
activity if needed.
Also, since Snap! runs in any modern browser, students can make
mobile apps for iOS or Android by putting a shortcut to the project's URL on
the device's desktop. From the browser we can't access phone-specific
information such as contact list or GPS position (standalone versions are in
the works), but things like video game projects work fine.
Snap! also connects with several robots and sensors (Finch,
Hummingbird, Sphero, Lego NXT, Wiimote, LEAP Motion, Arduino, etc.) by way of
small applications installed on the local computer.
Social Implications of Computers
Here are the topics included in the BJC units:
- Privacy and Search Engines
- Video Games and Violence
- Owning Ideas (Copyrights and Patents)
- Computers and Community
- social networks
- Computers and War
- Computers and Work
In all of these topics, our goal is to avoid preaching; we look for
alternate points of view. For example, we don't assume that pirating
copyrighted works is wrong; since many students do it, we try to elicit honest
perspectives on why it might be okay, and consider alternate ways to support
artists and writers. Both student pages and the Teachers' Guide point to
provocative readings on each topic.
In general, we hope to leave students feeling optimistic about the benefits
of technology, but also ready to think critically about any specific
technology. We also remind them that the decisions about how a new technology
is used are made by human beings, including themselves if they pursue a career
in computer science, so they shouldn't feel helpless in the face of a supposed
We use the excellent Blown to Bits
as the textbook for this part of the course. (There is no textbook for the
technical parts of the course, beyond the online materials we provide.) The
book is aimed at adult readers, and will be difficult especially for ESL
students, so we use short excerpts and discuss alternative presentations in
the Teachers' Guide. Like the rest of the course materials, this book is
avaliable free online, with a Creative Commons BY-NC-SA license.
The book is a few years old now, so we supplement it with current readings,
looking for topics that will be relevant to students. Students choose their
own topics to study in more depth; this is one way we appeal to a diverse
audience. We start class meetings
with "Computing in the News," presenting items from that morning's newspaper,
one generally positive and one problematic. After some teacher-chosen
examples to illustrate the idea, we encourage teachers to assign the selection
of articles to students in rotation.