Posts tagged ‘inquiry-based learning’

Please forward to high school history teachers: Task-specific programming in social studies data viz

Hi,

We built this tool, DV4L (Data Visualization for Literacy), to help teachers quickly create data visualizations for social study classes. This is currently a minimum viable product (MVP) version of our tool, and we would like to collect your feedback so that we can improve! 

  • Please take a few moments and try out our tool at http://b48ca06e.ngrok.io/index.html
  • We intend for DV4L to be intuitive and easy to use, so you shouldn’t need any instructions to start. (If you ever see a screen with ‘TOO MANY CONNECTIONS’ on the top, please just wait for a few seconds and refresh the page.)
  • After you have tried out the tool, please take a few minutes to fill out this survey at https://forms.gle/jASed4f7GfTZD9xa8

We would really appreciate it if you could do this by Sunday Dec 8th to meet our class requirements. 

Feel free to share this with any other teachers or students who would like to try this out. Thank you so much!

I have been working with a team of four University of Michigan Computer Science students (in a class with Elliot Soloway) to develop a data visualization tool for history classes. They have a prototype ready for testing, and they need user data for their class by Sunday, December 8. Could you please forward this to any high school (or middle school) history teachers you know? They would also love to get some feedback from high school history students, too.

Here are three reasons why I’m excited about this tool.

First, the team really listened to us, our history professor collaborator (Tammy Shreiner), and the social studies teachers who gave us feedback on different data visualization tools. One of the students drove 2.5 hours to attend a participatory design session with social studies teachers in October. As an example, there are driving questions for each database, to guide students in what they might inquire about — that’s a specific request from Tammy.

Second, this is a tool for history inquiry. Data visualization tools like Vega-Lite and CODAP are terrific. (Readers of this blog know how impressed I am by Vega-Lite.) But they’re not designed for inquiry. As Bob Bain has taught me, historical inquiry starts from two pieces of evidence or two accounts that disagree. This tool is designed to support comparing different pieces of evidence, and maintaining a trace of what you’ve explored. Inquiry is about comparison, not from building a single visualization.

Third, this is task-specific programming in a subtle and interesting way. You build visualizations by making choices from pull-down menus on the left. As you find interesting graphs, you save them to the right. When you want to remember what the graph is about, you hover over it and get a textual representation of what pull-down menus generated this graph. I’m arguing that hover text is a program —- it’s a representation of the process for generating that graph, and it serves as a reminder of where you’ve been. It’s a program whose value is in reading it, not executing it.

Amy Ko told me once (I’m paraphrasing) that a program is a description of a process for the future. Using a tool is for now. A program represents the future. This program could be executed by the user in the future — set the pop-up menus to the same values, and you’ll get the same visualization. More importantly, the program represents the past and serves as a reminder for what you can do next.

Please do pass this around so that our team can get a sense of what’s working and what’s not in this prototype. Thanks!

December 5, 2019 at 8:00 am 6 comments

An Ebook Integrating Minimal Manuals with Constructionism, Worked Examples, and Inquiry: MOHQ

Our computing education research group at Georgia Tech has been developing and evaluating ebooks for several years (see this post with discussion of some of them). We publish on them frequently, with a new paper just accepted to ICER 2016 in Melbourne. We use the Runestone Interactive platform which allows us to create ebooks with a lot of different kinds of learning activities — not just editing and running code (which I’ve been arguing for awhile is really important to support a range of abilities and motivations), but including editing and running code.

It’s a heavyweight platform. I have been thinking about alternative models of ebooks — maybe closer to e-pamphlets. Since I was working with GP (see previous post) and undergraduate David Tran was interested in working with me on a GP project, we built a prototype of a minimalist medium for learning CS. I call it a MOHQ: Minimal manual Organized around Hypertext Questions: http://home.cc.gatech.edu/gpblocks. (Suggestion: Use Firefox if you can for playing with browser GP. WAY faster for the JavaScript execution than either Chrome or Safari on my Mac.)

Minimal Manuals

John Carroll came up with the idea of minimal manuals back in the 1980’s (see the earliest paper I found on the idea). The goal is to help people to use complicated computing devices with the minimum of overhead. Each page of the manual starts with a task — something that a user would want to do. The goal is to put the instruction for how to achieve that task all on that one page.

The idea of minimalist instruction is described here: http://www.instructionaldesign.org/theories/minimalism.html.

The four principles of minimal instruction design are:

  1. Allow learners to start immediately on meaningful tasks.
  2. Minimize the amount of reading and other passive forms of training by allowing users to fill in the gaps themselves
  3. Include error recognition and recovery activities in the instruction
  4. Make all learning activities self-contained and independent of sequence.

There’s good evidence that minimal manuals really do work (see http://doc.utwente.nl/26430/1/Lazonder93minimal.pdf). Learners become more productive more quickly with minimal manuals, with surprisingly high scores on transfer and retention. A nice attribute of minimal manuals is that they’re geared toward success. They likely increase self-efficacy, a significant problem in CS education.

The goal of most minimal instruction is to be able to do something. What about learning conceptual knowledge?

Adding Learning Theory: Inquiry, Worked Examples, and Constructionism

I started exploring minimal manuals as a model for designing CS educational media after a challenge from Alan Kay. Alan asked me to think about how we would teach people to be autodidacts. One of the approaches used to encourage autodidactism is inquiry-based learning. Could we structure a minimal manual around questions that they might have or that we want students to ask themselves?

We structure our Runestone ebooks around an Examples+Practice framework. We provide a worked example (typically executable code, but sometimes a program visualization), and then ask (practice) questions about that example. We provide one or two practice exercises for every example. Based on Lauren Margeliux’s work, the point of the practice is to get students to think about the example, to engage with it, and to explain it to themselves. It’s less important that they do the questions — I want the students to read the questions and think about them, and Lauren’s work suggests that even the feedback may not be all that important.

Finally, one of the aspects that I like about Runestone is that every example in an active code area is a complete Python interpreter. Modify the code anyway you want. Erase all of it and build something new if you want. It’s constructionist. We want students to construct with the examples and go beyond them.

MOHQ: Minimal Manual Organized around Hypertext Questions

The prototype MOHQ that David Tran and I built (http://home.cc.gatech.edu/gpblocks) is an implementation of this integration of minimal manuals with constructionism, inquiry, and worked examples. Each page in the MOHQ:

  • Starts with a question that a student might be wondering about.
  • Offers a worked example in a video.
  • Offer the opportunity to construct with the example project.
  • Asks one or two practice questions, to prompt thinking about the project.

Using the minimal design principles to structure the explanation:

  1. Allow learners to start immediately on meaningful tasks.

The top page offers several questions that I hope are interesting to a student. Every page offers a project that aims to answer that question. GP is a good choice here because it’s blocks-based (low cognitive load) and I can do MediaComp in it (which is what I wanted to teach in this prototype).

#1: Minimize the amount of reading and other passive forms of training by allowing users to fill in the gaps themselves.

Each page has a video of David or me solving the problem in GP. Immediately afterward is a link to jump directly into the GP project exactly where the video ended. Undo something, redo something, start over and build something else. The point is to watch a video (where we try to explain what we’re doing, but we’re certainly not filling in all the gaps), then figure out how it works on your own.

Then we offer a couple of practice questions to challenge the learner: Did you really understand what was going on here?

#2: Include error recognition and recovery activities in the instruction.

Error recovery is easy when everything is in the browser — just hit the back button. You can’t save. You can’t damage anything. (We tell people this explicitly on every page.)

#3: Make all learning activities self-contained and independent of sequence.

This is the tough one. I want people to actually learn something in a MOHQ, that pixels have red, green, and blue components, and chromakey is about replacing one color with a background image, and that removing every other sample increases the frequency of a sound — and more general ideas, e.g., that elements in a collection can be referenced by index number.

So, all the driving questions from the home page start with, “Okay, you can just dive in here, but you might want to first go check out these other pages.” You don’t have to, but if you want to understand better what’s going on here, you might want to start with simpler questions.

We also want students to go on — to ask themselves new questions, to go try other projects. After each project, we offer some new questions that we hope that students might ask themselves. The links are explicitly prompts. “You might be thinking about these questions. Even if you weren’t, you might want to. Let’s see where we can explore next.”

Current Prototype and What Comes Next

Here’s the map of pages that we have out there right now. We built it in a Wiki which facilitated creating the network of pages that we want. This isn’t a linear book.

Full-MOHQ-Map

There’s maybe a dozen pages out there, but even with that relatively small size, it took most of a semester to pull these together. Producing the videos and building these pages by hand (even in a Wiki) was a lot of work. The tough part was every time we changed our minds about something — and had to go back through all of the previously built pages and update them. Since this is a prototype (i.e., we didn’t know what we wanted when we started), that happened quite often. If we were going to add more to the GP MOHQ, I’d want to use a tool for generating pages from a database as we did with STABLE, the Smalltalk Apprenticeship-Based Learning Environment.

I would appreciate your thoughts about MOHQ. Call this an expert review of the idea.

  • Thumbs-up or down? Worth developing further, or a bad direction?
  • What do you think is promising about this idea?
  • What would we need to change to make it more effective for student learning?

June 15, 2016 at 7:35 am 12 comments

Guided Computer Science Inquiry in Data Structures Class

Inquiry-based learning is the best practice for science education.  Education activities focus on a driving question that is personally meaningful for students, like “Why is the sky blue?” or “Why is the stream by our school so acidic (or basic)?” or “What’s involved in building a house powered entirely by solar power?”  Answering those questions leads to deeper learning about science.  Learning sciences results support the value of this approach.

It’s hard for us to apply this idea from science education and teach an introductory computing course via inquiry, because students may not have many questions that relate to computer science when they first get started.  Questions like “How do I make an app to do X?” or “How do I use Snap on my laptop?” are design and task oriented, not inquiry oriented.  Answering them may not lead to deeper understanding of computer science.  Our everyday experience of computing, through (hopefully) well-designed interfaces, hides away the underlying computing.  We only really start to think about computing at moments of breakdown (what Heidigger called “present-at-hand”).  “Why can’t I get to YouTube, even though the cable modem light is on?” and “How does a virus get on my computer, and how can it pop up windows on my screen?”  It’s an interesting research project to explore what questions students have about computing when they enter our classes.

I realized this semester that I could prompt students to define questions for inquiry-based learning in a second computer science class, a data structures course.  I’m teaching our Media Computation Data Structures course this semester.  These students have seen under the covers and know that computing technology is programmed.  I can use that to prompt them about how new things work.  What I particularly like about this approach is how it gets me out of the “Tour of the Code” lecturing style.

Here’s an example.  We had already created music using linked lists of MIDI phrases.  I then showed them code for creating a linked list of images, then presented this output.

An image created with PositionedSceneElement nodes

I asked students, “What do you want to know about how this worked?”  This was the gamble for me — would they come up with questions?  They did, and they were great questions.  “Why are the images lined up along the bottom?” “Why can we see the background image?”

I formed the students into small groups, and assigned them one of the questions that the students had generated.  I gave them 10 minutes to find the answers, and then report back.  The discussion around the room was on-topic and had the students exploring the code in depth.  We then went through each group to get their answers.  Not every answer was great, but I could take the answer and expand upon it to reach the issues that I wanted to make sure that we highlighted.  It was great — way better and more interactive than me paging through umpteen Powerpoint slides of code.

Then I showed them this output from another linked list of images.

Images that are both positioned and layered

Again, the questions that the students generated were terrific.  “What data are stored in each instance such that some have positions and some are just stacked up on the bottom?” and “Why are there gaps along the bottom?”

Still later in the course, I showed them an animation, rendered from a scene graph, and I showed them the code that created the scene graph and generated the animation.  Now, I asked them about both the animation code and the class hierarchy that the scene graph nodes was drawing upon.  Their questions were both about the code, and about the engineering of the code — why was it decomposed in just this way?

Questions-on-board

 

(We didn’t finish answering these questions in a single class period, so I took pictures of the questions so that I could display them and we could return to them in the next class.)

I have really enjoyed these class sessions.  I’m not lecturing about data structures — they’re learning about data structures.  The students are really engaged in trying to figure out, “How does that work like that?”  I’m busy in class suggesting where they should look in the code to get their questions answered.  We jointly try to make sense of their questions and their answers.  Frankly, I hope to never again have to show sequences of Powerpoint slides of code ever again.

 

 

 

March 26, 2013 at 1:57 am 7 comments


Enter your email address to follow this blog and receive notifications of new posts by email.

Join 9,005 other followers

Feeds

Recent Posts

Blog Stats

  • 1,879,912 hits
October 2021
M T W T F S S
 123
45678910
11121314151617
18192021222324
25262728293031

CS Teaching Tips