Jump to content
  • Advertisement
  • entries
  • comments
  • views

Google is not a programming teacher

Sign in to follow this  


Every now and then I spend a few spare minutes on a major programming forum participating in various discussions and helping with some questions. I've been idle there quite a bit lately, mostly due to having my energy and attention focused elsewhere, but once upon a time I put a fair bit of effort into GDNet. I haven't been banned or stalked by ninja assassins yet, so apparently I wasn't too unhelpful.

I've been doing the programming-forum thing for about 9 years now. Funny story: I originally started answering questions online in the hopes of drumming up contract jobs, as I was freelancing at the time. After almost a decade and tens of thousands of cumulative posts jammed into the tubes, I have yet to earn any business whatsoever from my efforts. Not a single contract. I quit freelancing a few years ago, but the irony of that never fails to amuse me.

In any case, when you spend that volume of time and attention on helping literally untold hundreds of people with their problems, you begin to see patterns. Lots of patterns. It doesn't take long for the same questions, same discussions, and same arguments to recur... over, and over, and over.

The old, slightly cynical, hardened forum veterans will sigh and point back to past threads. Sometimes, they'll post a comprehensive list of discussion related to the topic. Very rarely, the starter of the discussion will read through the history, learn his lesson, and move on silently, strengthened by the direction of the more senior member.

Usually, though, things just go straight to hell. A couple of people will always show up for certain discussions - their pet issues, hot buttons, whatever you want to call it. They'll get in and say the same stuff they say every time. Then some other newbies will show up and say something, sincerely believing that they are original and insightful - but the veterans have heard it before.

Sooner or later, patience dwindles, people get tetchy, and someone's toes get stepped on. The thread may flare up briefly into a flamefest before being locked, or before people just quit caring and don't read it any more. But they always die.

Then the thread gets buried, disappears into the black void that is "everything beyond page 1", and is never heard from again... until three days later, when some other bright-eyed newbie comes along and brings up the same topic. Naturally, nobody learns from last time, and everyone has to run through the cycle again.

This is the life cycle of technical forums, and (to an extent) social forums as well. I've been watching them for quite a while, and these patterns occur and recur in every forum with consistency and bewildering frequency.

There are days when helping people with programming questions on the Internet seems like a punishment once reserved for Sisyphus. Those are usually the days when I decide to stop reading forums for a while.

Forum veterans around the tube-o-sphere know exactly what I'm talking about. These phenomena are neither strange nor unfamiliar to anyone who has invested any significant time in a programming community online. But for all the cumulative brain-power that has been directed at this problem, there is as yet no solution.

There are certainly proposed solutions, and chief among them is the invocation of the all-powerful Google. (Once upon a time, before Google became synonymous with the word, the invocation used to just be "search.") If only these newbies would learn to search, we'd say back in 1998. If they'd search before posting, they'd find all the easy answers, and the volume of pointless questions would drop off quickly. Then, the forums would be reserved for the more interesting and deep discussions, and we'll all be happy.

I see this same exact sentiment echoed today, on GDNet itself in fact. The terminology changed a bit in the past 9 years, but the idea didn't: if all these new posters would learn to search, our forum quality would improve.

This, I am sad to say, is a tremendous fallacy, and reflects a serious underlying issue in how we collectively perceive programming education.

The problem is, quite simply, that newbies don't search because they don't know how. More accurately, even if they do search, they probably don't find the answers they want.

Somehow, the Internet has perpetuated this idea that the ability to search intelligently is orthogonal to deep understanding of a domain. This is a ridiculous belief. In actual fact, properly leveraging Internet search utilities (Google, forum searches, and so on) requires three things:
  1. You have to know the right words

  2. You have to know how to recognize the answer

  3. You have to know how to work a search engine

As a veteran of the Internet, it's tremendously easy for me to take these things for granted. I've seen my seniors and peers do the same, for a long time. We are all terribly mistaken.

Knowing the Right Words
This point was driven home to me in a painful way last night. There's a particular bit of low-level hackery I wanted to do on the Windows platform, involving keyboard hooks. The details are not important; suffice it to say, I've done this before, and know it is possible.

What I didn't remember was how exactly to do it, or where I'd learned the trick in the first place. I spent half an hour on Google trying fruitlessly to dig up something I knew was out there. I knew some of the right terms, even a good part of the answer, but couldn't find what I wanted. I couldn't think up that one magical keyword that I'd stumbled across the first time, and therefore couldn't find an answer that I'd already found before. I ended up solving the problem a different way.

Now, I'm no slouch when it comes to searching the Internet. I've watched a lot of my friends hunt and peck on Google, and in all candidness I think it's fair to say that my understanding and familiarity with search technology is much better than theirs for the most part. In fact, I only know of one person who is consistently better at finding things on the web than I am.

If I, a web veteran of a decade and a proficient searcher as well as a competent programmer cannot find an answer to a relatively simple question - an answer I've found in the past - how can we expect newbies to solve their own questions on Google?

Consider a typical programming newbie: someone who doesn't know the programming jargon, hasn't memorized arcane corner cases of dozens of APIs, doesn't deeply understand the interworkings of modern computer software and the causal relationships between various aspects of programming, has never seen the answer to their question, and maybe isn't even sure there is one. Just for kicks, they don't understand that Google doesn't speak English and can't parse their question meaningfully; the semantics of keywords, PageRank, and search engine optimization are totally unknown to them.

How is this person ever going to have a chance in hell of finding the answer they need?

Recognizing the Answer
This is a nice little bit of Zen puppetry. It turns up in many forms: you can't learn something until you already almost know it, the fuzzy understanding threshold, the Blub paradox, and so on.

The gist of it is simple, but profoundly important: you can't find the answer if you can't recognize the answer.

Imagine this coversation:

InquisitiveTwelveYearOld: I learned square roots today!
WiseElder: Cool... what's sqrt(25)?
InquisitiveTwelveYearOld: Uhmm... let's see... five!
WiseElder: Very good.
InquisitiveTwelveYearOld: Hey, I wonder... what's the square root of -1?
WiseElder: i
WiseElder, satisfied with his disbursement of knowledge, leaves the conversation.
InquisitiveTwelveYearOld: WTF?

The poor kid is now totally screwed. He's been given a perfectly correct answer, but has no means by which to understand it. He doesn't even recognize that it is the answer; for all he knows, WiseGuy is just messing with his head and being a jerk. Well, screw you, WiseGuy, and screw math... I'm just going to go play football.

And thusly we lose another bright young mind who could have done amazing things.

Working a Search Engine
This is not as easy as it may sound to people with lots of web experience. In fact, it's a particularly difficult skill in itself. The complex interplay of advertising revenue, PageRank whoring, system abuses, and mysterious algorithms makes searching a shot in the dark at best. We tend to think of Google as the gateway to all Internet knowledge, when in fact it's little more than a digital roulette game. We only persist in using Google as the de facto standard of searching because the roulette wheel happens to (seem to) pay out fairly often.

In reality, though, we never know what we might have missed. Sometimes the best results are on page 2, but if the results on page 1 are marginally satisfactory, would you bother going to page 2? If you get a mediocre answer on page 1, do you ever click through and read the stuff on page 2 to see if a better result is available?

What about page 34?

What about pages that aren't listed on Google? (Of course, some would theorize that the non-Googleable Internet does not really exist.)

If that isn't enough to drive home the seriousness of the problem, ask yourself one last question: if you can't even tell a good answer from a bad one, will you bother going to page 2?

What if you try to search, but only get back 10 pages of irrelevant crap, because you tried to do the one search Google can't do?

That is precisely the position we leave our newbies in when we tell them to search before posting their questions.

The Road to Hell is Paved With Bad Advice (and Stupid Sayings)
Clearly, the common advice to "search first" is misguided. A true newbie cannot search in any meaningful way, and has little hope of truly solving their problem by searching.

Worse, searching tends to yield popular but very bad answers to particular problems (*cough* I'm looking at you, CodeProject), which actually make this advice deadly. The Wise Elder recommends a search; the Newbie does a search and finds Bad Advice. The logical conclusion for the Newbie is that the Wise Elder endorses this Bad Advice, which probably is not the case.

Six months later, the Newbie (now promoted to Novice) comes back and asks another question; the Bad Advice has left him in a nasty position and he's not sure what to do. Wise Elder returns; he doesn't remember Novice, but Novice definitely remembers him. Wise Elder perceives that the real problem is Bad Advice, and sternly corrects Novice and his horrible misguided ways.

What sort of impression must that leave on the newbie?

I don't know how common that situation really is, at least in that particular form, but it happened to me back in my own newbie days - and still does, on occasion, when I venture into areas that I know nothing about.

So the world is broken. How do we fix it?
There's something that I think could cure this problem. It's not an easy solution. It doesn't scale. It isn't efficient, and it isn't much fun. In fact, it's more or less a pain in the arse - for some of us.

I remember back in my very, very early days of programming, before I understood algorithmic complexity notations and software design and coherent abstraction and all that cruft. Back when all I wanted to do was draw some cool animations on the screen.

I had a tiny bit of contact with the demoscene world, and I loved it. I wanted to do my own. But all I had was a musty copy of QuickBasic and a worn book that seemed to be aimed more at accountants and statisticians than graphics and game programmers.

This was before the Internet, so I had no way to find other people who could solve my questions. I learned a lot of bad habits (and just plain didn't learn lots of other things) because I had no one to learn from. The one thing I wished for most during those early days was for a Guru to come down from the mountains and mentor me, teach me everything I needed to know.

Gurus, as you may know, are in critically short supply, and generally like their mountains an awful lot. Therefore, I naturally didn't get my wish. I ended up having to fight to teach myself, often at great expense (for a high school kid), and usually with rather dubious results.

I've spoken to a few other programmers and heard similar stories. But, most tellingly, I'm watching a few friends start to learn programming themselves. The sentiment appears again, and again, and again - why can't someone just sit down and explain all this crap in some way that makes sense?

Just the other night I walked one of those friends through solving a trivial physics simulation problem. It was vector math - stuff I do in my sleep these days (quite literally) - and very simple equations at that. But this friend simply couldn't see how to solve the problem.

He emailed me the example code his professor had given as a guide for the assignment, and I immediately knew why such a pathetically trivial question had become an insurmountable obstacle: the professor's code was utterly, thoroughly, and completely terrible. In a five line function I spotted well over a dozen idiotic habits and decisions before I gave up counting - I had to close my eyes and look away lest the horror of it melt my retinas into my brain.

After I convinced my friend to ignore the professor and just think through the problem on paper, and write his own code, he solved it in a blink.

What newbies need isn't Google-fu. What newbies need is mentors. Twenty-first century high technology needs a good solid dose of eighteenth century apprenticeship.

Mentoring 101
To be quite frank I really don't know how mentoring works in practice. I never had a real programming mentor, and I've never really been one to anyone else. But it seems clear to me that therein lies the solution to the problem of educating new ranks of programmers.

I do know that mere "teaching" is no help. I've seen enough people struggle through abysmally bad "programming classes" to know they don't work. I've tried to teach a couple of them and swore to never again touch that quagmire of hopeless foolishness.

Call it cheezy or frivolous if you like, but I think the Zen method works pretty well. The masters should take the students in, a long-term and in-depth relationship. The student should be free to ask questions and explore on their own; the master should do what he can to facilitate this.

However, on a regular basis, the master should pose exercises to the student. These should be deep questions that require real learning to solve, not just busy-work (as is the norm in programming classes). Even better, these should follow the spirit of koans: oblique, obscure, and subtle questions that have no obvious or clear answer; they are not meant to be solved, but pondered, the master knowing that as the student considers the problem his understanding will be broadened.

Most importantly, though, we need to get away from the forum model for teaching newbies. It doesn't work. It goes well beyond "too many chefs in the kitchen" - it's too many chefs in a kitchen, which is also being used as a petting zoo, and simultaneously doubles as a nuclear physics research center. It's just totally screwed. Conflicting advice, an overabundance of perspectives, and disagreeing opinions are not things that newbies are prepared to handle, and yet we thoroughly drown them with such noise.

Instead, we need to take a leaf out of the old master/apprentice model: the master's word is law to the apprentice, at least until he gains mastery himself. There is only one master, to avoid the extra noise of conflicting views until such time as the student is prepared to handle them.

Of course this raises the all-important question of quality control. Without alternative views, how will we ensure that students are taught well? Just as in the days of apprenticeship, this problem solves itself rather elegantly. The masters who teach well will produce new masters. The results speak for themselves. Reputation is a powerful tool for the mentor model.

This is not a new idea. Mentoring of new programmers is a theme I've heard echoed widely, from the legendary Brooks, the Pragmatic guys, and even a few of my own seniors. Interestingly enough, it seems to come consistently from people who have attained true mastery, and are best qualified to speak on the matter. (And every now and then some hapless joker like me says it, too.)

Perhaps it is time we stopped simply talking, and put this model into practice. Where might software go, if it is helmed by a new generation of masters?
Sign in to follow this  


Recommended Comments

I had an experience like this. A guy I chatted with online was interested in learning C, so I walked him through setting up Dev-C++ and all those good things. I decided to try to teach him what I knew, so I explained concepts to him, set him tasks and so forth. It worked really well, and when he asked questions, instead of simply telling him the answer, I often would say "See if you can find the answer on this page" and give him a link to a good resource. In the end I didn't have enough time to sustain that kind of relationship, and he stopped learning after his first public example of his skills was criticized and ridiculed by the community at large, but it was fun while it lasted!

Share this comment

Link to comment
So--introduce forums which are publicly visible (through the mentor's profile), yet are postable only by a single mentor and his (one to three) apprentices?

Share this comment

Link to comment
Guest Anonymous Poster


Hm, welcome to the club. I did this, too, answering (and more seldom: asking) questions in the web, as an example at expertsexchange.com, but I started to stop that, too. Good answers seldom were appreciated (though I was 2001 on #3 for MySQL and somewhere in the top10 for Oracle/Java - who cares?). It's a petty, but eventually you give up... .

Good article, by the way!

Share this comment

Link to comment
Guest Anonymous Poster


Their is a problem with your idea. Programming is notoriously difficult to teach, there is no test to see if someone will be capable of it.

If someone does get it, if they understand how the machines work, than like you and the would be mentors they will learn it on their own, its a harsh world out here on the internet, and that is how the programmers natural selection works.

If they dont understand they are more likely to look for help from a mentor, and so the mentors will be swamped by people they can not teach looking for attention, at first they will help but eventualy most will give up.
The ones the mentors could actualy teach something are busy learning on their own, or very few and far between compared to the others so that it ends up not being worth it to find them.

Share this comment

Link to comment
Guest Anonymous Poster


I've been a developer for the past 25 years. When I started everyone I knew was mentored. There were seniors on the team who had that as part of their job description. I've always thought that socratic mentoring produced the best developers. It's the methodology I've always used when I had junior developers around. Some found it frustrating that I don't just "Tell them the answer dammit!" the bright ones liked the challenge. When they came to understand why I taught the way I did they seemed to make the leap from programmer to developer because they were proactively thinking about the syntax/problem space/job.


Share this comment

Link to comment
Regarding programming being hard to teach - I completely agree, and you describe the current situation perfectly.

However, I do not personally feel that this is the best arrangement. Just because it's how we do things now doesn't mean it's the only way it can be done; it doesn't even mean that it's a good way.

It took me 12 years of programming experience to truly understand how to create elegant, loosely coupled, flexible designs for large scale systems. That's twelve years of code, of smaller lessons learned the hard way, and of doing it wrong and getting bitten hard by my own mistakes. Now, I'm no prodigy, but I like to think of myself as non-stupid; twelve years is a long bloody time.

In the end, the final year or so of learning things on my own was cut short to literally about a week, as a much more experienced and wiser programmer dropped into my life for a while and took up the mentor role. After some serious epiphanies, it all clicked, and I was ready to go. Again, that week would have taken me at least a year of fooling around on my own to reach equivalent understanding.

All I'm asking is, is it not worth trying to shorten that time of learning? If we radically reduce the gestation period for "really good programmers", similar patterns in other fields suggest that we will see a corresponding explosion in the development of software creation processes and tools. In other words, if our masters take half as long to reach mastery, we should see a (roughly) twofold acceleration in the development of programming technology. I'm all for that.

There's a lot of personal experience underlying my thoughts in this post. Maybe the best way to summarize it is this: I've been writing code for over 15 years. It's been only relatively recently that I feel like I really began to understand design and how to build good systems. And yet, after 15 years, I have no idea how much more there is to learn - or even where to learn it from. Do any other fields have that problem? I'm not aware of any.

Note that I'm specifically thinking about instincts here, not factual memorization. Any schmuck can memorize a book of facts and regurgitate them; I've had the misfortune of working with a few "programmers" who operated that way, and the good fortune to replace one or two of them in jobs past. In my mind, a master is someone who no longer has to struggle to correlate facts and disparate principles, but has understood the big picture so thoroughly that they produce good results simply by instinct. Solving problems elegantly and powerfully is virtually automatic.

Compared to other fields that highlight such mastery (the classical arts, martial arts, architecture, and so on) programming seems devoid both of good ways to study a master, and good ways to recognize when mastery is attained. This is, historically, precisely what the apprenticeship model addressed.

Share this comment

Link to comment
The problem is, quite simply, that newbies don't search because they don't know how. More accurately, even if they do search, they probably don't find the answers they want.

Somehow, the Internet has perpetuated this idea that the ability to search intelligently is orthogonal to deep understanding of a domain. This is a ridiculous belief. In actual fact, properly leveraging Internet search utilities (Google, forum searches, and so on) requires three things:

1. You have to know the right words

2. You have to know how to recognize the answer

3. You have to know how to work a search engine

This sometimes holds true. I usually do try point them towards hints for how to google in this case, when I can recognize it. For more complex problems, I try to explain how I (or how I would) diagnosed, fixed, changed, searched for further information upon, etc., rather than giving empty answers.

On the other hand, it's often just that they're lazy. You get situations where I just copy the thread title, plug it into google, and paste it back into the thread and point out the very first result is relevant and/or solves the problem -- yet will post the same easily answered by a simple google the very next day, often reposts because they refuse to even find their not-very-old thread. You'll get IRC requests for topics which require bloody long dissertations, have good results with the simplest of searches (which they may refuse to even try in the first place), the posers of which will freely admit to their slovenliness when the question of why they didn't even try googling in the first place.

Share this comment

Link to comment

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now
  • Advertisement

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

We are the game development community.

Whether you are an indie, hobbyist, AAA developer, or just trying to learn, GameDev.net is the place for you to learn, share, and connect with the games industry. Learn more About Us or sign up!

Sign me up!