Introduction to Programming

Taking an introductory programming course this semester has been an interesting experience. Since I grasp the course material well, I’ve spent some time helping others with their work. As anyone who has taught math can attest, teaching even basic concepts requires you to understand the material far better than the student must. When it comes to programming, helping people is even more difficult because you can’t just tell them how to do it. You need to let them to figure it out on their own, otherwise they won’t have learned anything.

But leading someone along without explicitly telling them anything is really, REALLY difficult. Our professor is a master at this, and I respect him deeply because of it. A student will ask a question, and the professor will reply with an oblique statement that doesn’t seem to address the student’s question at all. Yet soon enough the student says “Oh! I get it!” and goes on their merry way. I try as hard as possible to emulate this method when I help those who are struggling, but it is nigh impossible to strike the correct balance. Help them too much, and they don’t learn. Help them too little, and they despair or begin to resent programming. And as much as I don’t like seeing it happen, many of the people in the class have come to resent programming.

This is as sad as a student resenting literature because of a bad English class experience, or resenting math because of a bad math teacher. Yet I don’t fully understand how to prevent it. If there was a good, standardized methodology for teaching difficult concepts without causing students to resent the field, I feel a lot of the problems in society today could be solved. Maybe that is just wishful thinking, though.

The second interesting observation from taking this class has come from observing a peer. The first language she learned was Python, and learning C++ this semester has caused some distress. There were many lamentations along the lines of “why is the computer so dumb?!” Of course, I found this hilarious because it mirrors a situation in the novel A Fire Upon the Deep. As the protagonists head towards the bottom of the Beyond, much of their advanced computer technology stops working, and they are forced to adopt more primitive methods. Needless to say, the characters who grew up with the advanced technology are indignant that they are forced to use such primitive technologies as a keyboard. Meanwhile, the character who grew up using primitive technology merely smiles.

In my mind, this helps clear up the argument of whether new students to the art of programming should be started on a high-level language, or a low-level language. Until such time as low-level programming is never needed except in rare circumstances, students should be started at a medium-to-low level. For example, it is easier to step up to Python from Java than it is to step down. I was originally of the mind that new students should start at a high-level as to learn common computing concepts without getting bogged down in obtuse technicalities and syntax, but getting a first-hand view of the results of such an approach has changed my mind.

Learning a Foreign Language

I have had the benefit of taking Japanese 1 this semester, and it is quite a humbling experience. Learning a language which has no romantic roots — a truly foreign language — lends a certain perspective that learning French or Latin does not.

However, it also seems to me that the teaching method is geared towards a very specific type of learning style. The class starts out by teaching a number of phrases which the students are to memorize, and meanwhile students also begin to learn one of the writing systems. It is not until a few weeks in that students finally learn some grammar (i.e. the thing that actually determines whether or not a communication system is a language), and even then it takes time to learn the exact mechanics behind the memorized phrases.

For instance, we learned how to ask how to say something in Japanese: (english word)wa nihongo de nanto iimasuka. Yet we are not told that nihongo means Japanese language (although it can be inferred), and we certainly aren’t told that ~go is a suffix, applied to the word nihon (Japan), which means the language of. In addition, we aren’t told that nan means what, ~wa is a topic particle (and we certainly aren’t told it’s spelled using は instead of わ, because hell, we don’t even know how to write at that point), or that to is a sort of quotation mark (if we are, it is only in passing and without context).

Insights can only be gleamed by comparing the response: (Japanese word)to iimasu. Now it becomes clear that ~ka is a question particle. So yes, nanto became (word)to, so ~to must be some sort of literal marker suffix. iimasu must be “say”, or thereabouts.

My point is that it is very hard for me to memorize phrases or words with no context. The teaching style is designed to help a certain type of learner. My learning style would benefit greatly from learning a variety of grammar and vocabulary separately, and letting my brain concoct the phrases from their base elements; when I speak, it flows logically, and my mind pronounces one morpheme at a time. Learning whole phrases with no context means I can’t break it down into morphemes, and so production of the sounds comes much harder.

Perhaps this will change after we get past the first few weeks, but I can’t help worrying that this sort of learn-specifics-then-learn-rules teaching style will continue.

%d bloggers like this: