The BJC Curriculum

Try the Curriculum

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 use.

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 database software.

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.

Visual Programming

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 functions:

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 this triangle:

For students who insist on programming in a text language, Snap! provides access to the Javascript environment in which it is implemented:

(The picture shows a one-liner, but there is no limit to the length or complexity of the Javascript function defined by the block.) With this capability we can have our cake and eat it too, with respect to the (pointless, we think) argument about block languages vs. text languages. We don't teach Javascript in BJC, but it's available as an enrichment 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 Computing

Here are the topics included in the BJC units:

  • Privacy and Search Engines
  • Video Games and Violence
  • Owning Ideas (Copyrights and Patents)
  • Encryption
  • Innovation
  • Computers and Community
    • Social networks
    • Cyberbullying
  • 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 technological imperative.

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.

About Snap!

Snap! is a visual programming language based on Scratch (MIT Media Lab), but extended to support more advanced computer science ideas, especially recursion and functional programming.