Minimal exposure

Adding Up

As I sat in my first Computer Science 61A lecture, I couldn’t help but feel like I was out of place.

The computer science department website calls the CS 61 series “an introduction to computer science.” But I quickly realized that many of the students in the class didn’t need an introduction to anything — not the basic programming concepts, and not even Python, which is the programming language that the course teaches.

The only thing CS 61A introduced was the fast pace of classes in the CS department.

Although my high school was academically rigorous, we didn’t have any computer science courses. When I arrived at UC Berkeley, I found that many of my peers had already been programming for years, whereas I was a true beginner to the subject.

I remember how frustrated I was when I couldn’t understand material as quickly as some of my peers. When the concept of recursion was introduced, it took me forever to understand how to successfully implement it in my programs.

I still remember the dreaded “Tower of Hanoi” problem — a mathematical puzzle that requires you to move a stack of variably sized rings while making sure that no ring is stacked on top of a smaller-sized ring. I sat in a homework party for an hour trying to make myself believe the recursive solution “just worked,” but I couldn’t.

The rigor required in any lower division “weed-out” course at UC Berkeley is already intense. Combining that pressure with being so behind everyone else in the class left me feeling frustrated. I often wondered if anyone in the class was actually new to programming, like me.

I didn’t feel so out of place in my other classes. In many of my mathematics prerequisite courses, it was unusual for students to already be familiar with the course material. Discrete math and linear algebra were still difficult, but I didn’t feel like I was at any disadvantage.

CS 61A was a completely different story.

Last fall, I had the opportunity to work as a lab assistant for Data 8: “Foundations of Data Science,” and I couldn’t help but notice the difference in atmosphere between the students in Data 8 and my own experience in CS 61A.

Data 8 is one of the alternative courses offered for UC Berkeley students who are new programmers. Data 8 and CS 10: “The Beauty and Joy of Computing” are offered to students who want to test the waters of programming before jumping into 61A.

Data 8 uses Python, just like 61A. But the concepts are taught more slowly so new programmers can really understand how to use these concepts properly in their code.

My Data 8 students were actually enjoying the assignments and weren’t worried about making mistakes. I realized that my own experience in 61A had been very disjointed because I was always worried that I wouldn’t understand something the minute it was discussed in lecture.

Interesting projects became sources of stress, and the course became draining as I continually worried about falling more behind.

When I was a freshman in CS 61A, I wrote CS off as a potential major very quickly. Even though I did just as well in 61A as I did in my math requirements, I felt more comfortable with math. Math wasn’t unfamiliar. But I often wondered: If I had studied computer science in high school, would I have felt differently?

Because I was new to programming — and 61A was more of a contest for a good grade on a midterm than anything else — I developed a negative perception of computer science and my ability in the subject.

Working with Data 8 students made me more hopeful that beginners could become successful programmers, even at UC Berkeley.

While CS 10 and Data 8 are good options for those new to programming, I do think 61A should be more accommodating to beginners. The large class size limits the ability for students to get help from TAs at office hours. As the pace of the course increases, beginners might still be struggling with topics from the start of the semester.

But as I have taken more CS classes at UC Berkeley, I’ve found hard work and determination can more than make up for a lack of exposure. In my four years, I’ve come a long way from my first 61A lecture.

Even though I’m in my senior year, programming can still make me feel like a beginner. I still make mistakes, and my code is never bug-free. But, as assistant teaching professor John DeNero continues to teach everyone in 61A, the only way to really learn programming is to just do it: Run the program, troubleshoot your bugs, and run it again.

Clare Egan writes the Monday blog on her experience in STEM departments at UC Berkeley. Contact her at [email protected] and follow her on Twitter at @cegan_dailycal.