Teaching Code, and Failure: Watch One, Do One, Teach One

Posted by admin in Digital Pedagogy, Teaching | 4 Comments

My father-in-law, a recently retired cardiologist, taught at UCLA Medical School for many years. I asked one day how med students learn so quickly the many procedures they perform on human bodies?

“Watch one, do one, teach one,” he replied.

In private office hours consults with each of my students in September, HTML5 and CSS3 kept coming up. Students want to learn it. They said employers expect you to have passing familiarity with it. But code is scary. It’s a language with many libraries. Unlike social media platforms, it’s not obvious how you would just jump in and teach yourself. Ten years ago, peoples’ first encounters with code were often hand-building websites. It’s a simple and immediately accessible way to cut your teeth. But now that platforms such as WordPress to do the heavy lifting for you, learning to code by hand-building a site means choosing to publish a less functional, less pretty website than you could make in one hour on WordPress. You have to code, fail and learn for a while before what you can build by hand looks better than a template.

As the ease of making and sharing gets increasingly simple, our distance from the full process of how objects get made and published is proportionally more abstracted. For example, I had to engage with an FTP client to load this site to my personal domain on my server. But that’s it: I’m done. I don’t have to think again about how the information I type on this site gets relayed to you. WP handles the many, many refreshes and new content. Purveyors of digital platforms build the tools, and we come. Apple’s app store had approximately 362K apps for download at the beginning of last summer; by the end, it was over 500K as this cool infographic from Gigaom suggests.

Working with code sparks a new way of looking at the human/computer interface. It lets you see “an interface.” You start to see how software and algorithms organize your life: beep to get your attention, herd you into little boxes where all your “content” gets “served” and where you can in turn dish it out to your “friends.” Eli Pariser, founder of MoveOn, has written well about how algorithms block viewpoints and people they think you will not brook. [See my post about Pariser on this problem.] Algorithms anticipate your wishes like Jeanie granting wishes for her “Master” in the 1960s sitcom I Dream of Jeanie. But we know who really had the power in that situation, right? The blond in the false eyelashes, her bare tummy glinting to the camera. All she wanted to do was please him! Isn’t that all Google wants? To please you really, really fast. And in delivering what you want in microseconds, it performs a kind of leger-de-main in which you don’t see the not-evil hand rifling through your click behavior, extracting it, and selling it to behavioral marketing companies that will build your unique Persuasion Profile identifying your particular interests, habits and vulnerabilities. That’s why Facebook and Google+ insist upon real names: your data is most valuable when it’s tied expressly to you and not a pseudonym.

Algorithms are, in the words of poet, professor and electronic literature author Brian Kim Stefans, “an unpleasant despot.” I’ll never be a programmer. But the consciousness borne of thinking through what code does in the world, and how and why people use it has changed my sense of what constitutes freedom. It’s also made me much more tolerant of failure because I understand failure to be a precondition of freedom.

“FAIL HARDER”

declares a sign taped to the transparent glass doors opening into Annenberg’s new Innovation Lab.

Failure hatches work-arounds that may not have been thinkable until you had an urgent need to solve the problem.

That’s why working with digital tools in curricular settings is essential. It’s even better if there’s a client, a deadline, the possibility of public failure. Watching Lynda.com instructional vids isn’t an adequate supplement without the public accountability. Tutorials on YouTube foster marginally more active learning than Lynda, because you have to adjudicate among the different search returns to figure out what actually you need to learn. But those forms of DIY [do it yourself] learning are kind of like multivitamin tablets: they purport to have all you need, but in practice you can’t digest all that value in the absence of other food-borne elements. When it comes to digital learning, there’s no magic pill. No substitute for working with tools in the classroom.

Academic culture is built upon the premise that failure is shameful: a sign of imbecility, or slapdash preparation. That’s why the Lab’s “FAIL HARDER” sign shocks. We are being exhorted to override our training and instinct to shelter ideas that may not be fully articulated, or practices at which we may not yet be masterful.

Whether or not we professors can take up the challenge to FAIL HARDER remains to be seen. My students are entirely up for the challenge. I am confident in our collective wisdom. I have watched with pleasure as they organized extracurricular meetings (which I didn’t attend), filled a google spreadsheet with information for our app, built a Facebook group to centralize workflow communication.

In a few hours I begin teaching those students jquery mobile, a programming language that templatizes standard features of mobile device navigation. Last summer I worked with code czarina Jeannette Altman on this film festival app. Mostly I watched her. Then I did a section, my modest “About.” Really my learning came from copying, then writing and breaking code to learn what specific calls did.

So I watched one. I did one. In four hours, I’m gonna teach one.

flickr image credit: Luis Machado

Share this:
Share this page via Email Share this page via Stumble Upon Share this page via Digg this Share this page via Facebook Share this page via Twitter

4 Responses to Teaching Code, and Failure: Watch One, Do One, Teach One

  1. Pingback: ProfHacker - The Chronicle of Higher Education

  2. Marzee says:

    Love this post, Kathi. It is interesting how people are afraid of “failure”. However, all of the best things in life (inventions, personal growth, great people, beautiful structures, methodologies, etc.) come through it. Seeing the product though, can we really call it failure? No. You only “fail” if you give up – if you fail to rise to the challenge, if you fail to overcome (even if it’s only in the smallest measure). I think as human creatures, it’s against our nature to “fail”. We have this inherent need to excel, to fight against the odds, to improve our measure. So long as we continue to struggle against the possibility of failure, we will always succeed, and hopefully exceed the challenges placed before us. Thanks for this thoughtful post.

  3. Marzee says:

    Actually – let me revise that. The only way we truly fail, is if we’ve learned nothing from the experience.

  4. This is just great, Kathi. But let me add to the record what I say to my programming students every year (’round about the third or fourth week of the semester):

    Right now, you’re probably feeling sort of stupid. “Why is this so hard? How is it that I walk out of class feeling like I get it, but then as soon as I go to write a program, I feel totally lost? Here I am in college (or grad school) and I feel like a third-grader.” So let me explain something about this feeling you have. I have been programming for about fifteen years. I am proficient in at least half-a-dozen languages, and dozens of frameworks and APIs. I’ve written tens of thousands of lines of code. I’ve built lots of systems. Systems that work properly, scale properly, and do the job. No one would deny me the title of “expert.”

    And so let me tell you truth. A truth that no serious programmer, however experienced, could ever deny. That feeling never goes away. Really.

    It never goes away, because every time you sit down to build something with a programming language, you’re essentially creating something that has never existed. It might strongly resemble other things, or be based on other things, but it’s always fundamentally new thing. And so the question really isn’t, “How do we get so good that we don’t have to struggle?” The question is, are we ready to make peace with our own stupidity? Are we ready to walk straight into the dark night? Are we ready to fail?

    Honestly, I will leave this class, go up my office, open a programming editor, and start either weeping or banging my head on the keyboard. Because I’m also right where you are.

    I could wax on about the spiritual meaning of this eternal September of the soul. Artists, I think, know exactly what I’m talking about. And it’s often something we conceal — as if new things just come out whole, instead of emerging from a series of failures and half-attempts, blind alleys and stupid ideas.

    You say, “I’ll never be a programmer.” Heavens. There is no engineer on the planet who could read this post and not think, “Are you kidding? You already are.”

    Steve

Leave a Reply

Your email address will not be published. Required fields are marked *

*