Six Reasons Why Computer Science Education is Failing Students

Interesting arguments from the CEO of LiveCode.  These two points are particularly interesting.  The first is: What sits between Scratch, or Alice, or App Inventor, and professional-class languages like JavaScript or C++?  I would put Python in there, but I still see that the Scratch->Python gap is a big one.  The second paragraph is really striking, and I’d like to see more evidence.  Does Israel’s great CS ed system lead to the strong startup culture, or is it because Israelis value technology that they have both a great startup culture and a great CS Ed system?

Up to about age 13 there are some excellent tools in widespread use, most notable among them being the free and popular Scratch from MIT and MIT App Investor  However students outgrow Scratch by around age 13 and schools often don’t make a good choice of language for the next phase in a child’s education.  Many traditional programing languages such as JavaScript or C++ are completely inappropriate for this age group.  Students struggle to understand what they are learning and often spend their lessons searching for a missing symbol.  The current generation of students use smartphones and so selecting a tool that allows them to create their own apps is another great opportunity to make learning directly relevant to them.  Our own LiveCode platform provides a handy solution to these issues by allowing students to create their own mobile apps using a programming language that is close to English.

I firmly believe that a strengthening computer science education program has to be one of the most obvious and cost effective things we can do to ensure future economic prosperity.  Israel has the highest rate of startup per capita anywhere and that in part stems from its strong computer science education program.  Estonia, another country with both a strong tech sector and economy, recently announced a plan to expand teaching of computer science to all primary school children.  Do we want to be left in the dust by these countries, or left unable to compete with the growing economies of India and China?  What is it going to take to get computer science education moved up the agenda in the USA and here in the UK?

via Six Reasons Why Computer Science Education is Failing Students.

Bret Victor’s “Inventing on Principle,” and the trade-off between usability and learning

I have had several people now send me a link to Bret Victor’s video on Inventing on Principle. It is a really impressive demo!

His system reminds me of Mike Eisenberg’s work on SchemePaint.  Mike wanted the artist to be able to interleave programming and direct manipulation.  In SchemePaint, you could draw something by hand, then store the result in a variable to manipulate in a loop.  Or you could write some code to tesselate some graphical object, then add tweaks by hand.  It was beautiful.  The work that Mike did on SchemePaint led to his wonderful work on HyperGami, a CAD system for origami, which was the start of his Craft Technology group. That’s the group from which Leah Buechley graduated — she did the LilyPad.

People are sending me Bret’s video asking, “Wouldn’t this be great for learners?”  I bet it could be, but we’d have to try it out. At one point in his lecture, Bret says, “Why should I have to simulate the computer in my head?”  Because that’s the point of understanding computer science.  Bret’s system looks like a powerful visualization system, and visualization can be used to lead to real understanding, but it isn’t easy to design the visualization and context such that learning occurs.

The problem is that visualization is about making information immediate and accessible, but learning is about changes in the mind — invisible associations and structures.  Sometimes good usability makes it easier to make these associations and structures.  Tools like Scratch and Alice increase usability in one direction (e.g., syntax) while still asking students to make an effort toward understanding (e.g., variables, loops, and conditionals).

My first PhD student was Noel Rappin, who explored the features of modeling environments that lead to learning.  He had a CHI paper about his work on helping chemical engineers learn through modeling.  Our colleagues in chemical engineering complained that their students couldn’t connect the equations to the physical details of the pumping systems that they were modeling. Noel built a system where students would lay out the physical representation of a pumping system, then “look underneath” to see the equations of the system, with the values filled in from the physical representation (e.g., height difference between tanks).

He ran a pilot study where students would lay out a system according to certain characteristics.  They would then manipulate the system to achieve some goal, like a given flow rate at a particular point in the system.  When Noel asked the pilot students if they gained any new insights about the equations, one student actually said, “What equations?”  They literally didn’t see the equations, just the particular value they were focusing on.  The system was highly usable for modeling, but not for learning.

Noel built a new system, where students could lay out a model, and values from the model were immediately available in an equation space.  To get the flow rate, the student would have to lay out the equations for themselves.  They would still solve the problem by manipulating the physical representation in order to get the right flow rate, and the system would still do all the calculations — but the students would have to figure out how to compute the flow rate.  The system became much harder to use.  But now, students actually did learn, and better than students in a comparison group.

Bret’s system is insightful and may have some terrific ideas for helping learning.  I’m not convinced that they’re new ideas yet, but an old idea in a new setting (e.g., JavaScript) can be powerful.  I worry that we get too entranced by improvements in usability.  In the end, learning is in the student, not in the system.

Mark’s Trip Report on ICER 2011: Students’ experience of CS classes, and making compilers more friendly

Last week was the International Computing Education Research conference for 2011 at Rhode Island College in Providence, RI. (What a cool city! My first time, and I enjoyed getting lost on one of my runs!)  It was the first time in years that I actually stayed for the whole conference, since I left after the first day last year.  I enjoyed realizing again why I loved this conference so much. Several of the papers were wonderful, the discussions and hallway chit-chat were terrific, and it was great to see so many colleagues, as well as meet people whose papers I’ve been reading but hadn’t yet met.

I’m labeling this “Mark’s Trip Report” because I’m not going to attempt to be thorough or fair in what papers I mention.  I’ll tell you about what struck me.  I’ll do a separate post just on the keynote.

The first set of papers were ostensibly about how students choose computing, but I thought that there was a strong subtext about understanding the student experience of a computing classes.

• Colleen Lewis talked about “Deciding to Major in Computer Science: A grounded theory of students’ self-assessment of ability,” but it was really much more about that “self-assessment” part than about the “deciding” part.  Colleen told us that a common theme in her interviews were the tension between growth vs. fixed mindset (drawing on Carol Dweck’s work). Many students decide early on that they’re bad at computing and they can’t get better, i.e., they don’t have the “Geek gene.” Those students won’t choose CS, of course, but for such a disappointing reason.
• Mike Hewner presented his work, which spoke to where students get their information about CS and how a good class experience can color a student’s perception of a specialization area.
• Päivi Kinnunen presented “CS Majors’ Self-Efficacy Perceptions in CS1: Results in light of social cognitive theory” which was about applying Bandura’s work (which explores how early failures at something lower students’ belief of their ability to do that something) to CS1.
  Päivi’s paper got me wondering what we’re telling CS majors when we have them use Alice or Scratch in CS1.  As we know from Mike’s work, CS majors know something about CS — they know something about the languages used in regular practice.  When we tell them to use Alice or Scratch, are we saying to them (in light of Bandura’s work), “You aren’t capable of using the real, authentic practice” and thus lower their self-efficacy?  And if we use a “real” language (even if harder) are we saying (in a Dweck growth mindset sense), “Yeah, this is hard, but you can do it.  You can learn to handle the real thing.”?

Päivi’s talk was a great set-up for Sally Fincher’s “Research Design: Necessary Bricolage,” which ended up winning the people’s choice (voted) best paper award (called the “Fool’s Award” at ICER).  Sally was asking how we go about gathering information about our students’ practices.  She said that we rely far too much on semi-structured interviews, and we should think about combining other methods and practices to gain more insight.  She showed examples of some of her research instruments, which were really wonderful (i.e., I plan to steal them as early as this semester!).  Here’s a neat combination of methods:  First, give students a graph of 24×7 in 30 minute increments, and ask them to mark when they work on the class.

That’s the “when.”  To get the “where,” Sally (and Josh Tenenberg and Anthony Robins) gave students cheap digital cameras, and asked them to take a picture of where they were working.

That upper left hand corner is a bus seat.  Would you have guessed that your students do CS homework on the bus?  Notice the mixture of affordances: In the bus, in the dorm room, in the lab with peers, at a table to work with friends.  Did you realize that students are working so much away from a rich computational infrastructure?  There’s no bottomline result here — rather, it’s about what data we should be gathering to figure out the things that we don’t realize yet that we need to know.

I enjoyed the papers by Cynthia Bailey-Lee, Beth Simon (for her paper on PeerWise with lead author Paul Denny — Beth’s name seemed to be on every-other paper this year!), and Matt Jadud because they were all replication studies.  Cynthia was taking a finding from Biology (on using peer instruction) and seeing if it worked in CS.  Beth and Matt were both taking earlier CS Ed papers, and see if they still worked in new settings.  It doesn’t matter what the bottomline finding was.  It’s so cool that our field is starting to go deep and check the work of earlier papers, to explore where it works and where it doesn’t, and to develop more general understanding.

Kathi Fisler presented a really interesting paper, “Do values grow on trees? Expression integrity in functional programming” that was particularly interesting for the variety of interpretations of the paper.  Kathi presented it as an exploration of whether function programming is “unnatural” for students.  I’m not sure how to ask that question.  What I found them exploring was, “How do novices and experts see the nested structure of s-expressions?  Do they see the trees?  Is that evident in their editing behavior, e.g., do they edit maintaining expression integrity, or do they ignore the parentheses when typing?”  Since so much computing involves the Web today, I’m wondering how comparable the results would be to people typing HTML (which is also a nested, tree-based notation).

I had a nice chat with Kathi’s co-author Guillaume Marceau who, with Kathi and Shriram, won the SIGCSE 2011 best paper award on designing error messages for students (which is an issue that has come up here recently).  I told Guillaume about Danny Caballero’s thesis, and he told me about why it’s so difficult to get error messages right for students.  The problem is that, by the time the parser has figured out what the problem is, all the context information to help the student has been thrown away.  An example is “identifier not found.”  For a student, a variable and a method/function name are completely different identifiers, completely different meanings.  It takes students a long time to generalize an identifier-value pairing such that the value could be an integer, an object, or a code block.  For most compilers, though, why you want the identifier is lost when the compiler can’t find an identifier’s meaning.  Racket contains compiler calls that help you construct the context, and thus provide good error messages.  He doesn’t hold out much hope for Java — it’s so hard just to compile Java, and refactoring it for good error messages to help students may be impossible.

Two other papers that I want to say brief words about:

• Simon’s paper on “Explaining program code: giving students the answer helps — but only just” follows up on the Bracelet work where students were asked to read and explain the purpose of a piece of code.  The students failed miserably.  Simon wondered, “What if we gave them the answer?”  Rather than have the students fill-in-a-blank about what the code did, he gave them a multiple-choice question where the answers were the top five guesses from the first study.  Yes, there was improvement. But no, performance was still appalling.
• Michael Lee presented on “Personifying programming tool feedback improves novice programmers’ learning,” which is a slightly wrong title.  What they did was to create a programming task (moving a little graphical character around on a board), but “personified” the parser.  A mistyped command might get the little character to say sheepishly, “I’m sorry, but I really don’t know how to do that. I wish I did.  I know how to do X. Is that what you would like me to do?”  I don’t think that the authors really measured learning, but what they did measure was how long students stuck with it — and a personified compiler is not nearly as scary, so students stick with it longer.  (See Bandura above.)

The papers will all show up on the ACM Digital Library soon.

Finally, Programming Environments for Blind Students

At CE21, I got a chance to talk to Chris Hundhausen who told me about his SIGCSE 2011 paper on building programming environments for blind students.  Susan Gerhart has challenged our community of computing educators to think about how our pedagogical tools can be used with visually disabled students.  She’s completely right — we tend to use graphical notations (as in Alice, Scratch, and Squeak eToys) to improve students’ ability to get started with computing, but those are useless for a blind student.

Chris is actually working on several different ideas including audio debuggers and manipulatives (physical artifacts) for representing the programs.  Chris said that his colllaborator, Andreas Stefik (Chris’ former student) is excellent at empirical methods, so all his design ideas are carefully developed with lots of trials.  The paper includes results from a test of the whole suite of tools.

I hope that lots of people follow-up on Chris’s work and direction.  My bet that what they’re finding will enable multi-sensory programming environments that will help everyone.

 

New GaComputes Reports for CE21

Next week is the first NSF Computing Education for the 21st Century Community Meeting, in New Orleans, organized and hosted by NCWIT.  In preparing for that meeting, we gathered some of our evaluation work into handouts, and now we’ve uploaded them to our website.  Some of the new things that might be of interest to readers here (Warning: Most of these are technical reports, not peer-reviewed publications!  The technical reports summarize analyses — lots of data, little explanation):

• 2-Page Summary of “Georgia Computes!” for the 2011 CE21 Meeting

• We generated this as a summary for high school principals about the work going on in the School of Interactive Computing around CS Ed:  2010 CS Education flyer
• A really interesting report coming out of the statewide survey of CS1 students that we did last year.  Trevisan, B., McKlin, T., & Guzdial, M. (2011). Factors Influencing CS Participation: Introductory Computer Science Students Describe What Led Them to Computing. (GaComputes! Technical Report). Atlanta: The Findings Group, LLC.
• An analysis of survey results that helps us identify the factors that influence women and members of under-represented groups in pursuing computing. Engelman, S., McKlin, T., & Guzdial, M. (2011). Conditions that encourage participation in computer science (GaComputes! Technical Report). Atlanta: The Findings Group, LLC.
• An analysis of where we are with respect to AP CS Level A in Georgia.  Engelman, S., McKlin, T., & Ericson, B, Guzdial, M. (2011). Georgia Computes! Advanced Placement Analysis (2010).(GaComputes! Technical Report). Atlanta: The Findings Group, LLC.
• This is some of the raw data that influenced the recent blog post on contexts in workshops, talking about robots, Alice, Scratch, Pleo dinosaurs, and PICO Crickets. Engelman, S., McKlin, T., & Ericson, B., & Guzdial, M. (2011).Georgia Computes! Roll-Up Analysis: Student Workshops August 2009 to August 2010. (GaComputes! Technical Report). Atlanta: The Findings Group, LLC.
• This is an assessment instrument that we use in the Operation: Reboot project (aiming at helping unemployed IT workers become computing teachers) to evaluate their attitudes toward teaching.  Trevisan, B., Engelman, S., McKlin, T., Ericson, B.& Guzdial, M. (2011). Operation Reboot’s Teaching Opinion Survey (GaComputes! Technical Report). Atlanta: The Findings Group, LLC.

Dancing and singing humans, even more than robots

I finished up the “Georgia Computes!” report on our first four years just before the holidays.  One of the evaluation studies we did was to look at the contexts that we use in our Girl Scout workshops and how those contexts influenced student attitude change.  We asked students before and after each event (for everything — summer camps, YWCA afterschool activities, as well as Girl Scout camps) whether they agreed or disagreed with seven statements:

1. Computers are fun
2. Programming is hard
3. Girls can do computing
4. Boys can do computing
5. Computer jobs are boring.
6. I am good at computing.
7. I like computing
8. I know more than my friends about computers.

In the one study, we looked at a set of workshops over a multi-year period with over 600 Girl Scouts involved.  We looked at where we got changes in attitudes, and computed the effect size. Here’s one of the tables of results:

This table shows the number of Girl Scout workshops that we had with each context, the number of large/medium/small effect sizes that we saw, and total number of effects. What we see here is that Pico Crickets and Scratch have the most effect: The most large effects, and the most overall effects.  We’ve done a lot of different things in our robotics workshops, from following mazes to singing-and-dancing robots.  Lego Mindstorm workshops (seven different ones, using a variety of activities) had only small effects on changes in attitudes.  This isn’t saying that Lego robotics can’t be an effective context for making more positive Girl Scouts’ attitudes about computing.  We are finding that it is harder than with these other contexts.  I hope that someone replicates this study with even larger n, showing an approach to using Lego Robotics with Girl Scouts that leads to many large effects on attitudes.  We just haven’t been able to find that yet.

Over the Christmas holiday, our extended family has been playing a bunch of great Wii games, including karaoke, “Just Dance,” and various Rock Band games.  Barb and I discovered this morning that we were thinking the same thing about these games: What a great context for learning programming! Barb was noting that “Just Dance” uses a small icon to represent (abstraction!) a particular dance move, which is then repeated several times (iteration!).  I was thinking about the great computing and media ideas required to build this kind of software: From digital signal processing to detect pitch, to the ubiquitous computing ideas involved in sensing the world (e.g., the accelerometers used to detect body motion in the dance games).  We could use an inquiry-based approach to teach computing through these (amazingly popular!) games, e.g., “How do you think Rock Band figures out if you’re singing the right pitch?” and “How accurate do you think the motion detection in ‘Just Dance’ is?”

This is how we should identify contexts to use in contextualized computing education.  What are the application areas that students find intriguing?  What computing ideas do we want to teach and can be taught with those areas?  Even though we may like robotics, if the student audiences that we’re seeking don’t, then it’s not a great context.  There are many great contexts out there, many that are even more popular and even more powerful than what we use today.  People like to sing and dance, even more than making robots sing and dance.  Learning to build software to support that sounds like a great context.

CMU’s CS Education Day

CMU has quite a star-studded CS Education going on today — http://www.cs.cmu.edu/csed/.  Jan Cuny of NSF’s BPC and CE21 programs is the keynote speaker, and includes themes of Alice, Running on Empty, Computational Thinking (from Jeanette Wing), and the Pittsburgh Science of Learning Center.  Links to lots of good resources on the page.

Mailing list for Alice Educators

Don Slater of CMU just posted this to SIGCSE-Members:

A mailing list for Alice educators is now available. On the alice-teachers list, educators will be able to ask questions, post ideas and nifty assignments, and support other members of the Alice teaching community. The list will be moderated to make sure that only those posts that are of interest to the Alice educational community will be distributed.

The following link will take you to a web page with more information about the list. This list is by subscription only but at NO COST and with NO SPAM. Please complete the form at this ListServ website to request a subscription to the list.

https://lists.andrew.cmu.edu/mailman/listinfo/alice-teachers

Multi-lingual Pedagogical Programming Environment: Pyjama

Doug Blank at Bryn Mawr is looking for people to try out and help with his new editor/shell IDE, Pyjama (http://PyjamaProject.org). Pyjama is built on Microsoft’s Dynamic Language Runtime. Languages in Pyjama can share data, functions, and objects.

Pyjama currently comes with support for four languages: Python, Ruby, Scheme, and Dinah (“a new language prototype similar to the Alice interface”).  There are YouTube videos available about using the shell and the editor. The current tool is written in IronPython with Gtk# for the GUI.  It runs under Mono for Mac and Linux.

Doug is looking for folks to help out with Pyjama.  Explicitly, he wants this to be an educator’s tool, written for and by educators. Doug told me about his reasons for Pyjama in an email:

The larger goal of Pyjama is to make it so that educators can easily switch between programming languages, or switch contexts and topics. For example, if you would like to do Alice 3D programming, but you would rather do it in Python, then you could. Or if you would like to use an Alice interface to control robots, then you could. In addition, if you would like to create a new language (or language environment, like Processing or Scratch) then you could. Or if you would like to create a new module (say in Scientific Methods) then that module will instantly be available to all of the Pyjama languages.

We (teachers) need to be in control of everything in the academic environment… If Java isn’t the right language, let’s build our own. If IDLE and Python doesn’t work just right, let’s alter it to suit our needs, not just use what is available.

Update on the AP CS Pilots

Lien Diaz of the College Board kindly gave me permission to share this information on the five pilot tests of the AP CS: Principles classes.

• Jody Paul is running the trial at Metropolitan State College of Denver for 20 students, using Scratch and HTML/CSS. http://LivingInAComputingWorld.org
• Dan Garcia is leading a team (with Brian Harvey, Colleen Lewis, and George Wang) for 120 students at Berkeley, using their BYOB version of Scratch. http://inst.eecs.berkeley.edu/~cs10/
• Beth Simon’s running the massive 750-900 student trial at UCSD with Alice and Excel. http://cseweb.ucsd.edu/~bsimon/
• Tiffany Barnes is teaching a class of 30 at U. North Carolina at Charlotte with Scratch. http://www.cs.uncc.edu/~tbarnes2/ComputingJoy
• Larry Snyder has a 20 person class at U. Washington (Seattle) using Python. http://www.cs.washington.edu/homes/snyder/

APCS Students can do Media Comp (and Alice) and Succeed

In the five workshops (which feels like a larger number than it sounds) that I ran this summer, I included some of the Exploring Wonderland book that Wanda Dann, Steve Cooper, and Barb Ericson wrote about learning AP CS through Alice and Media Computation.  Over half of the attendees from my workshops this summer were high school computer science teachers.  Overwhelmingly, the response that I got from those teachers was, “This is nice stuff.  Maybe I could use it in my earlier class (like Computing in the Modern World).  But I wouldn’t use it in AP.  That would take too much time away from the important stuff in AP.”

Of course, this infuriated Barb.  They designed the book to motivate students to dig into the AP content!  It just so happened that she got her chance to try out her design this last year. A local high school asked the College of Computing for last-minute help with their AP CS course.  A teacher who didn’t know AP (or CS, or even Java) was tasked with running the course, and he was smart enough to know that he needed help.  The school called the College, and the College asked Barb. Barb came in twice a week, wrote the lessons, and generally oversaw the content of the course.  Since she had just finished Wonderland, that was the easiest thing for her to teach.

She just sent me her scores.

7 get a 5 (4 males and 3 females)
4 get a 4 (3 males and 1 female)
2 get a 3 (1 male and 1 female) (a 3, 4, or 5 is passing)
-----------------------
4 get a 2 (3 males and 1 female)
and 13 get a 1 (9 males and 4 females)

While the gender scores were quite strong (e.g., more girls passed than failed), the under-represented minority minorities weren’t quite as strong.  All of her African-American students got 1′s.  However, one of her Hispanic students took one of those 5′s.

Those are really good scores.  Yes, most kids who took the test didn’t pass — the AP is hard, and that is the way it goes. What it shows is that students can succeed at the AP, even if you “waste” time with all that Alice, and Media, and motivation stuff.  This isn’t a study, much less publishable. It’s only the results from one course.  But it’s an existence proof.

CMU launches robot-based CS-STEM Program

CMU won the DARPA award to address the “geek shortage” that was discussed in Wired magazine a few months ago.  I had heard that they were going to use their RobotC language, but instead it sounds like they’re going to extend Alice. That’s promising!  Looking forward to see what they produce!

A new four-year, $7 million educational initiative by Carnegie Mellon University will leverage students’ innate interest in robots and other forms of “hard fun” to increase U.S. enrollments in computer science and steer more young people into scientific and technological careers.

The initiative, called Fostering Innovation through Robotics Exploration (FIRE), is sponsored by the Defense Advanced Research Projects Agency (DARPA) and designed to reverse a significant national decline in the number of college students majoring in computer science, science, technology, engineering and mathematics (CS-STEM).

via July 13: Carnegie Mellon Launches $7 Million Initiative Using Robots To Boost Science, Technology Majors – Carnegie Mellon University.

Back and Board

I’m back from an amazing vacation in Hawaii.  Highlights included running on a lava lake, exploring an undeveloped section of a lava tube, watching eruptions at night and from a helicopter, snorkeling in Kealakekua Bay with a dozen or more (hard to count fins on other sides of the bay) dolphins leaping and spinning around us, and watching fireworks while sitting in the warm sand at Waikiki.  I discovered again that I find surfing frustrating, and I newly discovered how much I enjoy Hawaiian Poke.

My inbox has an enormous unread count on it, of course.  My iPad arrived while I was gone, so I’m having fun using that to wade through the massive pile of missives.  Not all of my attention is on the email, though, since I am teaching five days of workshops in Massachusetts starting Monday.  This will be my first time to teach Scratch and only my second to teach Alice with Media Computation, and I have materials to prepare today.  I’m attending the last DCCE meeting of the year tomorrow.  If your note to me is in my inbox unread, my apologies and I’ll get to it as soon as I can, but probably not until next week.

One piece of relevant news.  You may recall that I posted my SIGCSE Board statement here last January. The election results were announced this last week, I’m honored to have been elected.  I am now a member of the ACM SIGCSE Board for the next three years, as one of the “members at large.”  It’s a great group of people on the Board, and I look forward to serving with them.

Media Computation and BPC-Related Workshops this Summer

Workshops on Media Computation and related topics on creating engaging introductions to computing are being offered this summer. The goal of these workshops is to encourage teacher innovation in broadening participation in computing by exploring new ways to introduce computing. The workshops are mainly aimed at undergraduate faculty, but are open to high school teachers as well. Details are available at http://home.cc.gatech.edu/gacomputes.

• June 14-15 in Amherst, MA: Workshop on “From Visual Programing to Media: Approaches to Starting Computing” including Scratch, Alice, and Media Computation. Hosted by Rick Adrion, Deborah Boisvert, and Renee Fall of CAITE, and co-sponsored by the CAITE and “Georgia Computes!” NSF BPC Alliances.
• June 16-18 in Cambridge, MA: Workshop on “Media Computation,” hosted by John Sanders of Suffolk University. Funding from NSF CCLI.
• July 5-6 at The College of New Jersey (Ewing, NJ): Workshop on “Media Computation,” hosted by Peter DePasquale. Funding from NSF CCLI.
• July 7-9 at Virginia Tech (Blacksburg, VA): Workshop on “Media Computation,” hosted by Manuel A. Perez-Quinones, Fudning from NSF CCLI and the NSF BPC Alliance “Georgia Computes!”

All of the “Media Computation” workshops this summer are including some content based on the “Exploring Wonderland” (Dann, Cooper, & Ericson, 2009) work combining Alice and Media Computation.

The workshops are free with generous travel stipends. Meals at the workshop are covered by the sponsors. Lodging and airfare funding is available for participants from outside the region.

Details on the workshop, including how to register, are available at http://home.cc.gatech.edu/gacomputes. Thanks to all the hosts for making arrangements for these workshops!

Pilot testing the new AP CS definition

Here at the AP CS Advisory Group meeting this weekend, the first five curriculum developers, teachers, and pilot testers of the “Computer Science: Principles” course definition were named.

• Beth Simon of University of California at San Diego will be teaching 900 students (!) in Fall 2010 using the new AP CS  definition.  She’ll use Alice with the book by Wanda Dann, Steve Cooper, and Randy Pausch. She’s also planning to use Excel. She’s planning to use a peer instruction model.
• Jody Paul will be teaching this class at Metropolitan State College of Denver. His is an open-enrollment school, so he has no control on pre-requisites of students.  He’s planning to focus on connecting students’ life experiences with the learning objectives about computing.  He is going to use Scratch and visualization tools.
• Larry Snyder of University of Washington, Seattle, is going to create a new course to parallel his successful fluency with information technology course. His new course will be in Python and will have a heavy emphasis on the Web, to relate computing concepts to a computational phenomenon that students care about.
• Dan Garcia is going to continue develop his course on “Beauty, Joy, and Awe of Computer Science.” His course uses a new version of Scratch called “BYOB” for “Build Your Own Blocks.”  BYOB-Scratch uses a Lisp-like computational metaphor, e.g., where lists can contain blocks, and a “Run” block can execute a piece of block/data in a list.  Dan’s course already hits most of the items in the new AP CS requirements.
• The fifth pilot tester is Tiffany Barnes of University of North Carolina at Charlotte who wasn’t able to attend the meeting, so I can’t report on her plans.  (She’s on leave this semester.)

It’s exciting that the five pilot-testers are going in such different directions, which in itself emphasizes the flexibility in the new requirements.  The overall curricular definition is up around 70 pages now — there’s a lot of definition to live up to.  What happens next with the AP CS depends a lot on these five.  God and the devil are both in the details.