A reader is seeking advice about how to teach programming to high school students. Justin James presents two approaches to teaching programming and explains why he prefers one approach over the other.
A TechRepublic member recently sent me the following email:
I'm planning to offer an Introduction to Programming course as part of my IT curriculum at the high school where I teach. I don't know much about programming so where do you recommend I start?
What kind of language should I introduce my students to? Java?
Here is the slightly edited version of my reply:
These are great questions that really get to the heart of a lot of things that have been discussed in the Programming and Development blog over the last few years. You are really asking two questions: (1) How do you get up to speed on programming to the point where you can competently teach a class? and (2) What kind of material is the best to teach? I think that both questions are much more closely related than you may suspect.
Two possible approaches
There are two possible approaches to this scenario. The first is the simple, industry standard answer: You learn enough about programming to put together some simple applications on your own with a language such as Java, C#, or VB.NET, and then teach the same thing to your students. This has the benefit of being a "safe" approach, in that it is no different from what anyone else is doing right now.
The second option is to forego the idea that you can teach enough real-world programming skills in the short time allotted (a portion of a school year, most likely) and instead teach programming fundamentals. Let's look at these options in a little more detail.Approach #1 The goal is to walk the students through learning some simple software development projects, starting with the "Hello World" variety and maybe moving up to a simple application that interacts with a database by the end of the course.
For yourself, you would probably want to do some basic reading on programming, and then progress with learning a particular language inside and out, so that you can adequately answer your students' questions. You may want to take a course at a community college or an institution such as DeVry University, ITT Technical Institute, Anthem Institute, etc. in order to facilitate this learning process. From there, you will have the necessary knowledge to walk students through building simple applications.
For this kind of course, Java, C#, or VB.NET are all up to the task, and there are free and low-cost development tools available to educational institutions so that neither the school nor the students would be under a terrible financial burden. A great alternative to those languages is Pascal, which was explicitly designed for its value as a teaching tool and is a perfectly fine language in its own right.Approach #2 The alternative is to put together a course that does not try to be a real-world programming course, but teaches the fundamentals that every good developer should know. There are a number of different "educational" programming systems out there, which include EdScheme, Logo, Alice, Small Basic, and Squeak/eToys. I am familiar with EdScheme, having gone through the basic book (The Little Schemer) in it when I was in high school. The EdScheme education course that I went through combined that book and software to let me write programs.
For a course like this, you should go through the material on your own and then dip your toes into some actual development.
The pros and cons of both approachesApproach #1
The big advantage is that your students might see some initial results, such as an on-the-screen application that looks like something is really happening. This might boost their self-esteem a bit and give them the willingness to go deeper with their studies. Another advantage is that there are plenty of resources out there for teaching like this and learning these kinds of systems.
One problem is that you will be doing a major disservice to your students. For one thing, it would take someone years of learning to be able to know enough to knowledgably answer a student's questions in this type of course. I suspect that, if you learn this on your own and then try to teach it, your greenness will show. Unless high school students are a far less cruel and judgmental crowd than I remember, all it takes is for you to make one or two rookie mistakes, and your credibility with them will be shot.
The other big problem is that teaching a course like this before the students have been through a program that taught them the fundamentals (such as the EdScheme program) is like trying to teach algebra to kids in kindergarten. Without the right base layer of knowledge, the students can manipulate the tools to produce the needed results, but they do not actually know what they are doing.Approach #2 With a program oriented to the fundamentals, you have a number of great advantages. For one thing, you will be dealing with a small subset of the things that real-world programmers encounter. As a result, fewer problems will come up, and so your lack of programming experience will not be a major liability. More importantly, you will be doing the students a favor: Those who go on to learn more about programming will receive a solid background in development. Also, I bet that you will find learning (and teaching) programming to be much less frustrating and much more rewarding with this approach.
The biggest problem with this approach is the main issue when teaching fundamental anything to high school students: They start saying things like, "This isn't what actual programmers use, so why are we learning it?" or "This doesn't apply to the real world." While the mature viewpoint is to say, "Yes, but you need to crawl before you can run," many people in the high school age group simply do not see it that way. In addition, the support for these educational programs is not as widespread, due in large part to a lack of major corporate backing.
The approach I prefer
If it is not obvious, I favor the second approach. Why? Because I went through something like it when I was in high school. First, we learned BASIC over one year; the next year we were taught COBOL; in the third year, the first half was EdScheme, and the second half was Pascal; finally, there was C or C++ (I didn't take that course, so I don't know for sure) in the fourth year.
In the first two years, there was a major "weed out" effect -- probably 75% of the students dropped the class, failed it, or did not take the second year. It was brutal (by the way, you see about the same numbers in college). What generally happened is that a few students with the raw talent bulled through it and "helped" (that's a euphemism for "let them copy the work") the other students along. But in that third year, when we worked through EdScheme, something magical happened. To this day, I point to that half-year course and say, "that's when I actually learned how to program." Everything before that, in BASIC and COBOL, was merely writing code. It was like the difference between trying to learn Spanish by watching Dora the Explorer and visiting a Spanish-speaking country for a year, or the difference between learning how to cook by making Hamburger Helper and having Julia Childs personally teach you.
I cannot say enough good things about the EdScheme program, and I definitely recommend it. If your students want to know why they are being taught something that isn't real-world programming, let them know that one of the biggest problems in the software industry right now is the fact the fewer and fewer programmers understand these fundamentals. You can ask any of the readers here at TechRepublic, and they will tell you the same thing. As someone who has been an interviewer, I promise you that the people who know the fundamentals are obvious and that they are much more desirable to employers.
Helping to teach the next generation of developers is something that I am very passionate about, as are many of the TechRepublic members. I would be glad to provide any assistance that I can in your endeavors, including coming to speak to your students if you are within a few hours' drive of Columbia, SC. If you are outside that area, perhaps one of the TechRepublic members would be interested in speaking to your students. In addition, I can check the local .NET developers groups in your area to see if anyone would be able to talk to the students.
I hope this helps!
Related resources from TechRepublic and ZDNet
- Why aren't schools adopting open source?
- What programming language should we teach?
- Next-generation students want careers in computing
J.JaDisclosure of Justin's industry affiliations: Justin James has a working arrangement with Microsoft to write an article for MSDN Magazine. He also has a contract with Spiceworks to write product buying guides.
---------------------------------------------------------------------------------------Get weekly development tips in your inbox Keep your developer skills sharp by signing up for TechRepublic's free Web Developer newsletter, delivered each Tuesday. Automatically subscribe today!