Posts tagged ‘computing education’

Open Letter to Future Students: On the Shortage of Computer Science Faculty

Thanks to Pat Yongpradit for sending the below links article to me. I knew that CS faculty have been complaining about the costs of the enrollment pressure.  This was the first I’d heard of the students rising up to complain, and even to recommend to future students not to go into CS.

Being able to take on and graduate its own majors, which the department already strains to do, is the bare minimum of what we should expect from a department at a liberal arts college. As much as Haverford likes to present itself as an environment where each student can explore a diversity of academic interests and cultivate a multifaceted worldview, right now the CS department is unable to help broaden the education of non-majors. It has even been forced to eliminate the CS minor, because non-majors simply cannot get into upper-level courses to complete it. That this should be necessary at an institution of our caliber is shameful, and as the situation continues to deteriorate it will actively undermine the institution’s status. What kind of a college, prospective students are (appropriately) thinking, cannot offer its students the ability to understand how computing works? Deception by omission from the admissions office about the availability of CS courses is a very limited tool in holding back this information, as illustrated by the recent open letter to admitted Bryn Mawr students urging them to consider not enrolling if they are interested in science (especially CS).

Source: Open Letter: On the Shortage of Computer Science Faculty

April 23, 2018 at 7:00 am Leave a comment

Finding a Home for CS Ed in Schools of Ed: Priming the CS Teacher Pump Report Released

Thursday April 12, the report on finding a home for CS Ed in Schools of Education was released at Microsoft’s Times Square offices.  Leigh Ann DeLyser and Frances Schick of “CS for All” did a great job pulling it all together.You can see the play-by-play (or tweet-by-tweet) of the event on the Twitter stream #home4CS.  The report is available on the website http://www.computingteacher.org/.

Some of the points that I found particularly interesting or compelling:

  • Yasmin Kafai talking about the tension between standalone CS classes and integrating CS into other disciplines.  The latter is likely how CS is going to end up in K-8, and budget concerns may make that the most common path to giving high school students access to CS education. But our research shows that it’s really hard to make that work well.  CS will likely get little attention, if programming is just used as the tool for some STEM learning activities.  Questions from the audience were skeptical that we could get teachers to pay attention to both CS and the integrated subject well.
  • A big question was how to add something to US Schools of Education that are facing enrollment declines and budget cutbacks.  Aman Yadav addressed that point head-on, by identifying the courses that we’re already teaching in pre-service development programs where CS education could be integrated.
  • The discussion afterward was really great.  Participants stuck around for more than an hour to talk about these issues.  A common theme I heard was, “Give us the answers.  What are the best pre-service CS teacher PD programs?  What are the models we should be using?  Where are the syllabi for these courses?”  I don’t think that these are answerable questions in the US.  We don’t have one education system. We have one in each state.  Almost nothing transfers as-is from one state to another, from one university to another.  I’m more interested in the points that Joanna Goode made — how do we grow education leadership to understand the issues of CS Ed?  We need to inform the leaders who know their contexts to help them integrate CS Education.
  • I spoke about the challenges of growing a pipeline of CS Education Research PhD’s. One of the questions I got about my topic was, “What is the biggest lever for increasing the number of CS Ed PhD’s?  Is it just money?”  For my colleagues in Schools of Ed, money would really help — they don’t get enough funding.  For those of us in CS, it’s also the creation of PhD programs that meet the needs of CS Ed researchers.  Georgia Tech’s Human-Centered Computing PhD is great for that.  A traditional CS PhD is not a great fit, because it typically requires courses in systems development and theory that don’t help a CS Ed researcher and cost time and effort.

The report makes a bunch of recommendations, but doesn’t offer many answers.  It does start a conversation about how to make CS education sustainable in the US, which is a critical topic for long-term survival of the “CS for All” movement.

 

April 16, 2018 at 7:00 am 10 comments

A job is a strange outcome measure: Udacity drops money-back guarantee on finding a job

Udacity has dropped a money-back guarantee that they were offering to students in some of their Nanodegree programs. The guarantee (with stipulations and caveats) was that students would find a job after getting the nanodegree, or they would get their money back.

An article in Inside Higher Ed (quoted below and linked here) describes some of the tensions. Other for-profit coding schools offer similar or better guarantees, but others do not. Ryan Craig, quoted below, suggests that Udacity might not have been hitting its targets for job placements. Does that mean that Udacity was doing something wrong?

A job is such a strange outcome measure for any kind of educational program.  I know some techniques for evaluating someone’s knowledge of programming, and I know how to create educational opportunities that might lead to successful evaluation.  There are factors like student attitude and motivation and whether students engage in deliberate practice that are not entirely within my control.  Even then, I’d be willing to say, “I can design a program where the majority of students will achieve this level of proficiency in coding.”  But a job?  Where I can’t control how the students interview, or where they apply, or what the companies are looking for (if they’re looking at all)?

A job is not a well-defined outcome measure for an educational intervention. That may be what the students are seeking, but they are being unrealistic if they think that any school can guarantee them that.

Ryan Craig, managing director of investment company University Ventures, noted that none of the major employers associated with Udacity will publicly commit to hire or interview nanodegree candidates. Craig pointed to a 2017 report from VentureBeat, which stated that of around 10,000 students who had earned nanodegrees since 2014, around 1,000 had found jobs as a result. “A placement rate of around 10 percent should spell the demise of any last-mile training program,” said Craig.

Craig said the effectiveness of Udacity’s job guarantee was likely very limited for students. “Money-back guarantees don’t address the real guarantee that students are seeking: a job,” said Craig.

Daniel Friedman, co-founder of coding school Thinkful, wrote in January 2016 that Udacity’s guarantee was vaguer and weaker than the guarantees offered by his own company and others such as Bloc and Flatiron School. Such guarantees are common at coding schools, though Friedman noted that some schools have had to drop guarantees because they conflicted with state regulations.

April 13, 2018 at 7:00 am 3 comments

High School CS Teacher’s Experience like University CS Teacher’s: “Code Shock”

Jeff Yearout has been teaching for over 25 years, and is just in his second year of teaching CS.  His concerns in his blog echo many of the same ones that I hear from higher-education CS teachers, e.g., dealing with the wide variance of students, and getting all students to engage around code (pseudo or otherwise).

I think one of the hardest things to manage in designing a curriculum is how to dial the difficulty up at a proper pace for the “center mass” of the class skill level. And in this new curriculum from PLTW this particular unit starts out manageable, but suddenly shoots up rapidly, thus the “code shock” mentioned above. I also have the challenge of having a lot of kids in class who simply don’t want to interact in class when, for instance, I’m working through pseudocode on the board.

From “Teaching CS is Hard

April 9, 2018 at 7:00 am 2 comments

Teaching to develop a mental model of program behavior: How do students learn the notional machine

“To understand a program you must become both the machine and the program” – Perlis 1982, cited in Sorva 2013

I’ve been thinking for a few years now about an open research question in computing education. How do students come to understand how programs work? Put in a more technical way, How do students develop their mental model of the language’s notional machine?

I have been thinking about this question in terms of Ashok Goel’s Structure-Behavior-Function (SBF) model of how people think about systems.

  • Structure is the parts of the system — for us in CS, think about the code.
  • Function is what the system does — for us in CS, the requirements or the description of what the program is supposed to do.
  • Behavior is how the structural elements interact to achieve the function. It’s the understanding of the semantic model of the programming language (the notional machine) plus how that plays out in a specific program.

There are studies of students learning notional machines (e.g., Raymond Lister and Juha Sorva are some of the top researchers here). What I don’t know is how it develops and how to help it develop. Lister tells us the stages of development (e.g., of tracing skill). Sorva tells us about theories of how to teach the notional machine, but with little evidence. We have models for how people learn to read and write code (e.g., Elliot Soloway’s plans). But we not have a cognitive model for how they develop a mental model of how the code works.

A Pedagogical Problem That I Faced

I’m teaching Media Computation (n=234) this semester, and students had a disappointing performance on two programming problems on a recent quiz. (We have a 30 minute quiz every other week.) They didn’t really bomb, but an average of 82% on one programming problem (Problem #3 below) and 76% on the second (Problem #4) was lower than I was hoping for. Those are all mostly due to partial credit — only 25 of my 234 students got full credit on Problem #4. Worse yet, we had a “simple” matching problem where we offered four pictures and four programs — which program generated which picture? More than half the students got at least two wrong. The score on the matching problem was 72%, even lower than the programming task problems. My conclusion is that my students can’t yet read code and understand it.

How do I teach my students to understand code?

With my researcher hat on, I don’t have a solid answer. With my teacher hat on, I have to do something. So, I drew on what I know from the research to come up with a best guess solution.

I decided to drop the next two lecture topics from the schedule, to instead re-focus on manipulation of pictures. I know from the learning sciences literature that it’s much better to go deeper than broader. Teaching for mastery is more important than teaching for coverage. Things that students know well are more likely to persist and transfer than things that students are merely familiar with.

I decided to do a live-coded session revisiting the quiz. I had graded a bunch of the programming problems on the quiz. I saw several different strategies for solving those two problems. I had a unique teachable moment here — every student had attempted these two problems. They were primed for the right answer. I decided to solve the problems in a live-coding session (starting from a blank editor, and talking aloud as I wrote the code) in each of the ways that I saw students doing it — three ways for the first problem, four ways for the second problem. While I wrote, I drew pictures to describe the behavior, drawing from Sorva’s visualization approach and the SILC emphasis on sketching rather than diagrams. After writing each program, I tested it on a picture. Along the way, I answered questions and wrote additional examples based on those questions.

This idea is based on Marton’s Variation Theory. You have to vary critical aspects of examples for students to figure out the differences. Janet Kolodner talks about a similar idea when she emphasizes contrasting cases for learning informed by case-based reasoning.  In SBF terms, I was keeping the Function constant, but varying the Structure and Behavior. In Goal-Plan-Code terms, I was achieving the same Goal, but varying the underlying Plan and Code.

Could an exploration of these variations/contrasts help students see how the code changes related to behavior changes?  I don’t actually know how to evaluate the result as a researcher, but as a teacher, I got good response from students.  I’m looking forward to seeing how they do on similar problems on future quizzes.

The rest of this blog post is a static replay of the lecture. I’ll show you the slides I showed, the sketches I made, and the code I wrote (while talking aloud).

Problem clearTopHalf

Solution #1: Iterate through all pixels

def clearTopHalf1(pic):
  h = getHeight(pic)
  for pixel in getPixels(pic):
     y = getY(pixel)
     if y < h/2:
       setColor(pixel,white)

Solution #2: Iterate through half of the pixel indices

def clearTopHalf2(pic):
  all = getPixels(pic)
  for index in range(0,len(all)/2):
    pixel = all[index]
    setColor(pixel,white)

Solution #3: Iterate through all x and y positions in the top half

def clearTopHalf3(pic):
  h = getHeight(pic)
  w = getWidth(pic)
  for y in range(0,h/2):
   for x in range(0,w):
    pixel = getPixel(pic,x,y)
    setColor(pixel,white)

A student asked, “Could we do x first and then y?” Sure!

def clearTopHalf3b(pic):
  h = getHeight(pic)
  w = getWidth(pic)
  for x in range(0,w):
    for y in range(0,h/2):
       pixel = getPixel(pic,x,y)
       setColor(pixel,white)

Pause for Reflection and Discussion

At this point, I asked students to turn to the person next to them and ask, “Which one do you prefer? Which makes the most sense to you?”

I always encourage students to discuss during peer instruction questions. I have never had such an explosion of noise as I did with this invitation. From wandering around the room, what I heard students discussing was, “This is what I did, and this is what I got wrong.”

When we had the whole class discussion, the first and third approaches (all pixels or coordinates) were the preferences. Students who spoke up disliked the index approach — it felt “like there’s too much indirection” (said one student).

Problem copyThirdDown

Solution #1: Iterating through all pixels

def copyAThird1(pic):
  h = getHeight(pic)
  for pixel in getPixels(pic):
    x = getX(pixel)
    y = getY(pixel)
    if y < h/3:
      targetPixel=getPixel(pic,x,y+(2*h/3))
      setColor(targetPixel,getColor(pixel))

Solution #2: Iterate through first 1/3 of pixels

def copyAThird2(pic):
  all = getPixels(pic)
  h = getHeight(pic)
  for index in range(0,len(all)/3):
    pixel = all[index]
    color = getColor(pixel)
    x = getX(pixel)
    y = getY(pixel)
    targetPixel = getPixel(pic,x,y+(2*h/3))
    setColor(targetPixel,color)

Solution #3: Iterate through top 1/3 of picture by coordinates

def copyAThird3(pic):
  h = getHeight(pic)
  w = getWidth(pic)
  for x in range(0,w):
   for y in range(0,h/3):
    pixel = getPixel(pic,x,y)
    color = getColor(pixel)
    #Copies
    targetPixel = getPixel(pic,x,y+(2*h/3))
    setColor(targetPixel,color)

At this point, someone said that they did it by subtracting y from the height. I showed them that this approach mirrors. This is the first incorrect solution that I demonstrated.

def copyAThird3b(pic):
  h = getHeight(pic)
  w = getWidth(pic)
  for x in range(0,w):
    for y in range(0,h/3):
      pixel = getPixel(pic,x,y)
      color = getColor(pixel)
      # Mirrors instead of copies
      targetPixel = getPixel(pic,x,h-y-1)
      setColor(targetPixel,color)

Solution #4: Iterating through the bottom 1/3 of the picture by x and y coordinates

This was an unusual approach that I saw a few students try: They used nested loops to iterate through the bottom 2/3 of pixel coordinates, and then compute the top 1/3 to copy down. They iterated through the target and computed the source.

def copyAThird4(pic):
  h = getHeight(pic)
  w = getWidth(pic)
  for x in range(0,w):
    for y in range(2*h/3,h):
      targetPixel=getPixel(pic,x,y)
      srcPixel=getPixel(pic,x,y-(2*h/3))
      setColor(targetPixel,getColor(srcPixel))

After I wrote that program, someone asked, “Couldn’t you make an empty picture and copy the top third into the new picture at the top and bottom?” With her guidance, I modified the program above to create a new version, which does exactly as she describes, leaving the middle third blank. So, this was the second incorrect version I wrote to respond to student queries.


def copyAThirdEmpty(pic):
  h = getHeight(pic)
  w = getWidth(pic)
  canvas = makeEmptyPicture(w,h)
  for x in range(0,w):
    for y in range(0,h/3):
      pixel = getPixel(pic,x,y)
      color = getColor(pixel)
      targetPixel = getPixel(canvas,x,y)
      setColor(targetPixel,color)
      targetPixel = getPixel(canvas,x,y+(2*h/3))
      setColor(targetPixel,color)
  explore(canvas)

When I asked students a second time which version made the most sense to them, there was a bigger split. Indexing the array continued to be the least preferred one, but students liked both versions with nested loops, and many still preferred the first version.

April 6, 2018 at 7:00 am 14 comments

States requiring CS for all students may be making a mistake: Responding to unfunded mandates

As of this writing, New Jersey and Wyoming are the latest states to require CS for all their students (as described in this article) or to be offered in all their schools (as described in this Code.org post and this news article), respectively.  Wyoming has a particularly hard hill to climb.  As measured by involvement in AP exams, there’s just not much there — only 8 students took the AP CS A exam in the whole state last year, and 13 took AP CS Principles.

In 2014, I wrote an article titled “The Danger of Requiring Computer Science in K-12 Schools.”  I still stand by the claim that we should not mandate computer science for US schoolchildren yet. We don’t know how to do it, and we’re unlikely to fund it to do it well.

I can’t find any news articles describing what funding New Jersey and Wyoming are going to put toward the goal of teaching CS across their state.  How do you teach every student CS or teach CS in every school without any increase in funding?

Based on what we’ve seen in other US states, I predict one of three things will happen:

  • States will have to loosen the definition of “computer science,” as happened in South Carolina.  90 classes count for the CS requirement in South Carolina, and only 6 of which have programming in them.  Most of them are about keyboarding skills or application software use. If a state doesn’t fund real CS, something else will have to count as real CS.
  • States will rely heavily on virtual high schools and on-line classes to provide CS class “access” without hiring more CS teachers, as we are seeing in several states. That is particularly concerning since recent studies are showing that remedial students do poorly in on-line classes.
  • Independent CS classes will be deemed too expensive. Instead, the mandate to teach CS to all will lead to integration into math and science classes, which are already funded. School will have changed the reform, again (see Papert’s “Why School Reform is Impossible.”)

Neither of the first two options furthers the goal of having high-quality CS education for all students. The third one may be the best position, if funding doesn’t appear.

April 2, 2018 at 7:00 am 24 comments

How to Study for a CS Exam

I just recently finished Make It Stick (Amazon link) which takes modern learning science and develops recommendations to learners on how to study in order to learn most effectively. As I read it, I was wondering, “What are the implications for how students should study for a computer science exam or quiz?” I did a Web search for “computer science study skills,” and the results were disappointing. Most of the recommendations are wrong (e.g., “take good notes” and “highlight passages in the book”) and were not specific to learning computer science.

So, I wrote up some recommendations for my students. I have not tried to generalize these yet (but would be fun and useful to do so), and I haven’t gone back through Making it Stick to mine it for all the CS recommendations that one might invent from their lessons.

Caveat: these are “evidence-based” as in the learning sciences behind them is pretty solid, but they are not “evidence-based” in the sense of actually testing these practices with learning CS. We know that some learning sciences or educational psychology results from other fields don’t map cleanly to CS (see Briana’s work). I don’t know of research evaluating study practices for learners studying computer science — but it would be great to have some!

I’d be interested to hear how you help your students study computer science!  Please do share your ideas and recommendations in the comments.

How to study for a programming quiz

Here are my suggestions for how to study for Monday’s quiz (with some advice that is useful for all your other CS quizzes).

1. Read the Book. Once

If you haven’t read the relevant chapters, do read them. If you have already, I don’t suggest re-reading them. There are better ways to study than re-reading.

2. Do Your Programming Homework

The Collage Project (and all your other homework) is good preparation for Monday’s Quiz. Finish that up this weekend, and you’ll have reviewed many of the ideas needed for Monday’s Quiz.

3. Make sure you know what you didn’t know

Go over your homework assignments and past quizzes, and make sure that you now know everything you got wrong in the past.

4. Quiz Yourself

The best way to study is always by quizzing yourself. You’ll learn far more from quizzing yourself than from re-reading or reviewing your notes.

Use the problems at the back of the chapter. Get with others in the class and challenge each other by inventing variations on programming problems you have seen before:

  • Rather than create a negative of the whole picture, can you negate just the top half of a picture?
  • Can you move the bottom half of a picture onto the top?
  • Can you mirror a square picture diagonally?
  • Can you put a 100-pixel wide border of grayscale around a picture?

5. Elaborate on each Chapter

At the beginning of each chapter is a list of Learning Objectives — media learning goals and CS learning goals. Write a sentence or two demonstrating that you have learned those objectives. Explain what the goal means, and show that you have achieved those goals. Elaboration helps you to connect ideas so that it’s easier to remember those ideas later.

At the end of each chapter is the Programming Summary that lists the new programming ideas (new functions, new control structures) in that chapter. Make sure that you can use each of those. Just write a program, any program that uses each function at least once.

6. Try things in more than one way

In this class, you know more that one way of doing things.

  • You can get and set colors with setRed, getRed, setBlue, getBlue, setGreen, getGreen. OR getColor, setColor, makeColor. Make sure that you can use these interchangeably. Write increaseRed and decreaseRed using setColor. Write negation and grayscale with both sets.
  • You know several ways of accessing individual pixels.
    • You can use for pixel in getPixels(picture).
    • You can get all the pixels in a list with all = getPixels(picture) then generate the indices for that list with for index in range(0,len(all)): and access each pixel with pixel = all[index].
    • You can generate x and y coordinates with for loops, then get individual pixels with getPixel(picture,x,y).
    • Make sure that you can use all three well. Write chromaKey with all three forms. Create a green border around a picture using all three forms.

Take any program that you have written before, or that we have done in class, and rewrite it another way. This is both a form of elaboration and a form of quizzing.

7. When confused, ask and talk CS

Ask on Piazza. Ask your friends. Come to office hours. When studying, all collaboration is strongly encouraged.

Just talking through things (both what you understand and what you do not understand) with anyone will help you learn.  Explain your programs to someone else.  Summarizing your programs in English is a great way to make sure you understand the programs and to elaborate on your knowledge.

March 30, 2018 at 7:00 am 5 comments

Older Posts


Recent Posts

April 2018
M T W T F S S
« Mar    
 1
2345678
9101112131415
16171819202122
23242526272829
30  

Feeds

Blog Stats

  • 1,498,507 hits

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

Join 5,248 other followers

CS Teaching Tips