Background and Purpose: Designing a Computational Thinking Curriculum
Last year, I attended the 2018 Wolfram Summer Camp. I could talk about how amazing it is to be around people who are experts in the Wolfram Language. I could talk about how amazing it is to learn the Wolfram Language and in two weeks carry out mathematical research (or any type of research you find interesting). I could even talk about all the fun people I got to hang out with and all the crazy games I had fun playing.
But I'm going to talk about my takeaway: my takeaway from Camp was enthusiasm for Computational Thinking and the Wolfram Language. I returned back to my high school and started a Computational Thinking Club.
In the club, we met once every two weeks for an hour to explore Computational Thinking through the Wolfram Language. I eventually found, however, that I wanted to expand the scope of Computational Thinking at my school. So I decided to try to do something more. I landed on the idea of a course and proposed that to the administration, and the administration agreed. So I ran with the idea.
I came to the 2019 Wolfram Summer School to develop the curriculum for this pilot course. My purpose in creating this curriculum was to build interest and excitement about Computational Thinking and the Wolfram Language in my school community, or in other words to develop a culture of Computational Thinking. What I have designed is very much an experiment, but I think this experiment will give valuable data about what it takes to create a culture of Computational Thinking. My goal is that this curriculum will create enough excitement among the students and administration at my school that the school will integrate Computational Thinking and the Wolfram Language into their curriculum.
What is Computational Thinking, and Why is it Useful?
As it turned out, the first thing I did once I got to the Wolfram Summer School was to write a persuasive Computational Essay about the power of Computational Essays (here is an interactive version and a static version), which explores (and, I believe, clarifies) some of the ideas about Computational Literacy and Computational Languages put forward in Stephen Wolfram's blog post on the topic. My essay was chiefly directed at convincing teachers and students--especially in humanities--that Computational Essays are a powerful and necessary tool.
In that essay, I defined and explored the relationships between Computational Essays, Computational Language, Computational Literacy, and Computational Thinking. I examined these terms in the context of specialized, discipline-specific essays, languages, literacy, and thinking in the academic world. I landed on the following definitions:
A Computational Essay is an essay that harnesses a new type of evidence to prove its thesis. This evidence is computation.
A Computational Language fuses the natural language character of English or philosophy language, the precise character of symbolic math language, and the computer-interpretability of a programming language.
Computational Thinking is the process of conceptualizing ideas in a way that a computer can understand.
Computational Literacy is the ability to use Computational Thinking to read and write Computational Language, for example reading and writing Computational Essays.
Or, as I restated this in my Course Purpose and Goals document for my curriculum:
- What is Computational Thinking? (CT) Computational Thinking is the process of conceptualizing a problem in a way that a computer can assist with solving it. Think about mathematics word problems. You developed a way of thinking that allowed you to take the word problems and convert them into mathematics to find a solution, and then convert that solution back to the context of the word problem. Computational Thinking is analogous to this process, except that instead of simple word problems, you are solving real-world problems in mathematics, science, language, history... almost any subject you can think of. And instead of just mathematical notation, you use a Computational Language.
- What is a Computational Language? (CL) A Computational Language fuses the natural language character of English or philosophy language, the precise character of symbolic math language, and the computer-interpretability of a programming language. A Computational Language is carefully designed (this is not an easy task) to be written and read by both humans and computers. In learning a Computational Language, you become Computationally Literate (in the same way you may become mathematically literate by learning to understand math symbols or philosophically literate by learning to understand the definitions and logical relations in philosophy). The Wolfram Language is our Computational Language.
Writing that essay helped me clarify my goals for the course even further: given an audience who does not know about Computational Thinking and is not woven together by another common interest, my goal is to catch, and then retain, their interest so that they will learn Computational Thinking and the Wolfram Language for themselves.
Design
Sessions
The course is designed based on 50-minute meetings once per week for a full year, but is flexible in how it can be applied.
The 50-minute meetings are divided into 20 minutes of weekly topic discussion and 30 minutes of work/Q&A time each week. The 20 minutes of discussion is dedicated to discussing a particular application of Computational Thinking each week. The applications cover a wide range of disciplines and include varying levels of sophistication, including applications to both modern research and coursework, humanities as well as engineering. The 30 minutes of in-class work are for students to either work through a chapter of An Elementary Introduction to the Wolfram Language (EIWL) or complete another of the activities scheduled for that week. In particular, the participants can ask questions that come up during their exploration, whether they are struggling with a particular concept or curious to learn more about a particular detail of syntax or usage.
Each session ends with an exit ticket that allows students to reaffirm or change their path, give an update on what they worked on this session, and respond to something that came up during the session.
Optionally, an additional resource that would help participants is to hold weekly office hours where participants can come if they have time to ask questions and have longer discussions. Participants who are already very familiar with the Wolfram Language can serve as mentors while pursuing their own projects.
Paths
A unique feature of this design is that it allows students to choose how much time to spend on the course. This flexibility allows busy students to learn Computational Thinking while also allowing motivated students the opportunity to move at a faster pace. Naturally, different students will have more time than others to spend in "Computational Thinking Land" (where the local "language" spoken, which we must learn, is the Wolfram Language), and they will have different amounts of time to devote to the material in this course, so it is divided into three different "paths", based on the amount of time they want to spend learning Computational Thinking:
Tourist: As a "Tourist," busy students need not spend any time on Computational Thinking outside of class time each week. Tourists will gain an appreciation for the power of Computational Thinking through the weekly discussions while gaining a basic grasp of the Wolfram Language through dedicated in-class study time.
Study Abroad: As a "Study Abroad" student, students can spend approximately 2 hours per week outside of class time. In addition to the in-class work, Study Abroads will use their extra time each week to read additional articles about Computational Thinking and applications of the Wolfram Language, and to move through the Wolfram Language learning materials faster to gain a comprehensive grasp of the Wolfram Language. They can also use the Wolfram Language to complete small challenges and projects throughout the course if they desire.
Expat: As an "Expat" / "Expert" / "XP", students can spend 4+ hours per week outside of class time. Expats will gain a comprehensive grasp of the Wolfram Language in the first half or so of the course, and can use the second half of the course to pursue a project (a research project, a creative project, etc.) that is of personal interest to them using Computational Thinking and the Wolfram Language. Students are strongly encouraged to consider this path even if their primary topic of interest is not one traditionally associated with computation, as the power of the Wolfram Language is that it allows us to apply Computational Thinking to a rapidly-expanding set of fields outside of CS and STEM.
The distinction between the three paths is fluid, though there may be some catching up necessary to move from a lower to a higher path. Recommendations for what students should complete from week to week based on what path they are in are listed under each session of the course.
Depending on their chosen path, students will gain various levels of fluency in the Computational Language that is the Wolfram Language, but they will all gain Computational Literacy.
Platform
I implemented this all in Google Classroom, mainly because it was free and easy to use, and also because it can easily be ported to any other Learning Management System.
Session Topics
Topic Design
The part of this curriculum that I think is the most powerful is the session topics. The session topics are designed to catch the interest of a person who is asking the question "what could I use this for?" by showing a) what Computational Thinking and the Wolfram Language are capable of, b) a few replicable examples of using Computational Thinking and the Wolfram Language for that topic, and c) providing further resources for students to pursue that capability further.
Part of the power of the session topics, I believe, is their balance of generality and specificity. They must be general enough that they catch the interest of a broad set of the students, and they must be specific enough that they can be directly applied by the students to something that is important to them. If the session is too specific, then it may miss the interests of most of the people in the group, and may appear to have little meaningful application to those who are interested. If the message is too general, then it will be dismissed as an unattainable ideal--the participants will not believe in their own capability to carry anything out. This balance is hard to strike, but I think it is the most important part of the design.
It is also easy to add and rearrange topics. Because the goal is to showcase different, general examples each week in order to catch interest, the topics need not be connected from week to week (unless there is sustained interest, in which case it is easy to find/create additional sessions that go deeper into the material). This means that sessions can be rearranged or omitted depending on the interests of the group. The template which I have built (attached at the bottom) makes it very easy to create your own sessions to match the interests of your group. Ideally, these sessions can then be shared to create a broad repository of topics to draw from.
Choosing Topics
In choosing the topics which I have built sessions for, I have considered carefully the existing culture at my school. For example, I have chosen to focus on topics like text analysis, since my school is very strong in the humanities, and since text analysis is one of the more surprising areas of application for Computational Thinking and the Wolfram Language.
I have also tried to avoid repeating topics that are already present in EIWL unless that particular topic is a very important one to emphasize.
Although my interest is in mathematics, I avoided creating mathematics sessions because mathematics is already an obvious application of Mathematica/the Wolfram Language (my goal is to show people applications relevant to them that they wouldn't even think about).
Currently, I have built sessions for the following topics:
- The Notebook Interface
- Wolfram|Alpha
- The Wolfram Repositories, Community, and other resources
- Word Clouds
- Maps
- Literary Style
- Social Network Graphs in Plays
- Wolfram Challenges
- Semester Recap & Wolfram Summer Camp
Planned Guest Speakers include:
- An alumni who uses the Wolfram Language
- A current student who attended the Wolfram Summer Camp and will share about their project
I'm also currently planning to build sessions for:
- Intro to Data Science
- Intro to Machine Learning
- Cellular Automata
- Raspberry Pi
- Intro to Statistics in the Wolfram Language (this ties into one of the core courses at my school)
Session Examples
It's probably easiest to understand what I'm building by seeing it, so here is a selection of topics that I cover that exemplifies my ideas.
Emphasis on Exploration
Example Session: Wolfram|Alpha
Naturally, Wolfram|Alpha is one of the first lessons that I cover because it serves as an entry point into the computational realm for a vast number of subjects. It especially has an amazing ability to deal with things that you wouldn't expect. It gives people a clue what is possible with computation.
The session outline consists of watching an 80-second video introduction to Wolfram|Alpha, followed by simply jumping to Wolfram|Alpha and exploring. There are a number of linked examples to explore, and I also included one example inside the notebook itself on Hamlet.
Wolfram|Alpha is unique in its broad application and approachability. This means that I don't need to show people a bunch of examples of what it can be used for. Instead, I give them a few examples to spark their curiosity, and they can follow what catches their interest.
This is an example of how you can build a session simply by taking one thing and prompting people to explore it however they want. This is really effective when the topic is approachable without much demonstration needed.
Using Preexisting Material
Another really powerful thing is simply to reuse preexisting material. You can do this in many different ways: simply referencing and going through a resource, copying a resource into the session to put your own spin on it, or taking existing code and editing it to serve a different purpose.
Example Session: The Notebook Interface
This is one of the first sessions and is built almost entirely from an existing presentation on the topic, which I copied into the notebook. The session goes over notebook structure, the different possible input formats, the meaning of [SHIFT]+[ENTER], variables, text and numbers, and functions. It also features a few links as well. I could never have written something like this on my own, but because I was able to copy a resource I had into a more recognizable format, this was actually one of the easiest sessions to create.
Example Session: Maps
GeoListPlot[GeoNearest["Volcano", Here, 30]]
This is one of the few sessions whose material is also covered in EIWL. I built it because I wanted to get to topic sooner: I wanted students to start using maps in their class assignments and papers, and maps are another one of those surprising and useful aspects of the Wolfram Language. My approach to this was to copy a large amount of the material and code from EIWL's chapter on the subject, but to add my own annotations, modify the code a bit, and to add one extra piece (on DynamicGeoGraphics) that wasn't in the book. With just a little adaptation, I was able to create a nice little piece that showed several things that can be done, allowing people to follow up from there.
Example Session: Social Network Graphs
Here I repurposed code from a Wolfram blog post about creating social network graphs from plays. However, since my school studies Hamlet, but not Othello, I changed it to work on Hamlet instead. It's actually surprising how little work it took to adapt this. In fact, this code is fairly easy to adapt to any Shakespeare play (I'm hoping that someone next year will adapt it to Richard III on their own, since I think that play would prove extremely interesting to analyze computationally).
Graph[
edgesReduced,
VertexLabels -> "Name",
VertexStyle -> {_ :> RandomColor[]},
GraphLayout -> "GravityEmbedding"
]
Tying it all Together
Here's an example of a session that I feel has a good set of original material.
Example Session: Literary Style
This session covers doing word searches in text (which is itself an application of computational thinking), the function FindTextualAnswer, and a specific example of analyzing different speakers in a play. Here's the part about comparing speakers in a play. I'm going to add annotations in [square brackets]:
Comparing Speaking/Writing Styles:
[Clear statement of purpose.]
The task is to stylistically compare different speakers in a play.
To do that, let's get the text of Hamlet again and clean it up, leaving only the character dialog (using code from previous sessions):
[I can reuse code. If necessary, we could go over it. By this point, students probably know enough that they can understand what's going on. The important thing is that this code will always work, and will never need fixing.]
hamlet = ResourceData["Hamlet"];
hamletdialog = StringDrop[hamlet, 702];
hamletdialog = StringDelete[hamletdialog, Shortest["[" ~~ ___ ~~ "]"]];
hamletdialog =
StringDelete[hamletdialog,
Shortest["\nACT" ~~ ___ ~~ "\n"] | Shortest["SCENE" ~~ ___ ~~ "\n"],
IgnoreCase -> True]
// FixedPoint[StringReplace["\n\n\n" -> "\n\n"], #] &;
Let's pick three particular characters, say Hamlet, Claudius, and Ophelia. If we look at the text, we see that Hamlet is "Ham.", Claudius is "King.", and Ophelia is "Oph.". We can therefore extract their lines:
ham = StringCases[hamletdialog,
Shortest["Ham.\n" ~~ dialog__ ~~ "\n\n"] :> dialog];
cla = tringCases[hamletdialog,
Shortest["King.\n" ~~ dialog__ ~~ "\n\n"] :> dialog];
oph = StringCases[hamletdialog,
Shortest["Oph.\n" ~~ dialog__ ~~ "\n\n"] :> dialog];
[The code up to this point has been easy to modify, relatively understandable, and works without modification. It's also fairly easy to modify for a different text. Now begins the exploration section, where the code may be a little bit harder to understand, but is still only one line.]
We can then do WordClouds:
WordCloud@*DeleteStopwords@*Flatten@*TextWords /@
<|"Hamlet" -> ham, "Claudius" -> cla, "Ophelia" -> oph|> // KeyValueMap[Labeled[#2, #1] &]
We're now in a position to answer a multitude of questions about these three characters' styles (this could of course be expanded to the whole set of characters). Who speaks the most words?:
In[1]:= Total /@ WordCount /@ Flatten /@
<|"Hamlet" -> ham, "Claudius" -> cla, "Ophelia" -> oph|>
Out[1]= <|"Hamlet" -> 10595, "Claudius" -> 3542, "Ophelia" -> 977|>
Who tends to speak the longest, on average?:
In[2]:= Mean /@ Map[
WordCount, <|"Hamlet" -> ham, "Claudius" -> cla, "Ophelia" -> oph|>, {2}] // N
Out[2]= <|"Hamlet" -> 29.595, "Claudius" -> 33.1028, "Ophelia" -> 17.1404|>
Get a histogram about the differences in speech length (you can fiddle around with the PlotRange option to look at different parts of the plots). This generates a histogram showing the distribution of uninterrupted speech lengths in the characters' dialogs:
Histogram[#, PlotRange -> All] & /@
Map[WordCount, <|"Hamlet" -> ham, "Claudius" -> cla, "Ophelia" -> oph|>, {2}]
There are many, many more questions that one can ask about the text. For example, is a particular sentence that you're citing for your essay statistically longer than the rest of the character's sentences in the play? There are all sorts of questions you can ask!
[It's now fairly easy for the student to substitute their own analysis idea on the dialog and to explore for themselves. They can quickly find out the insights they personally are interested in, either now, or when they return to this notebook and rerun the code in a few weeks when they are writing their Hamlet paper.]
Hopes for the Future
My goal is to develop a culture of Computational Thinking at my school.
My first short-term goal is that this pilot creates a culture of Computational Thinking at my school, creating enough excitement, both among the students and among the instructors, that we can implement a Computational Thinking course or otherwise integrate Computational Thinking into the curriculum.
My second short-term goal is that other students are able to use this material to build excitement and a culture of Computational Thinking at their own schools and test this approach in many different environments.
I do also have a third, more long-range hope, however. One of the unique attributes about the instructors at my school is that they are simultaneously 1) teachers, 2) subject matter experts, and 3) curriculum designers. My hope is that they become interested enough in Computational Thinking to help start to develop subject-specific Computational Thinking courseware (think subject-specific variations of EIWL, or subject courses that integrate Computational Thinking and the Wolfram Language).
What I've created here is something new and untested. I look forward to seeing what happens.
Acknowledgements
Thank you to all of the many, many people (staff and students) at the 2019 Wolfram Summer School and Wolfram Summer Camp for all their help and insight, including Paul Abbott, Jonathan Gorard, Robert Nachbar, Flip Phillips, Matthew Szudzik, Christopher Wolfram, Catherine Wolfram, Mads Bahrami, Rory Foulger, Jesse Friedman, Zhamilya Bilyalova, Nikki Sigurdson, Harshal Gajjar, Katja Della Libera, Sylvia Haas, Peter Barendse, Julian Davis, Egar Almeida, Mark Greenberg, Russell Chipman, Ahmed Elbanna, Ilker Aslantepe, Roger Yu, Hee-Young Shin, Henry Kim, Vladimir Portnyk, Emmy Blumenthal, Silas Grossberndt and Stephen Schroeder.
Particular thanks to my mentor Daavid Väänänen, program director (and enthusiastic supporter) Kyle Keane, and program coordinator Erin Cherry.
Thank you to Stanford University Online High School Head of School Tomohiro Hoshi and Assistant Head of School Anthony Smith for their support of this project.
Thank you to Stephen Wolfram for creating and continuing to support the Wolfram Summer School.
And thank you to my parents for all their support in my endeavors!
Attachments:
