What are the pedagogical methods for teaching programming?

Question

This is a very objective question. I want to know what are the methods for teaching programing?

I'll provide a parallel example to make this clearer in case this causes any confusion.

I have Portuguese as a native language and I teach English here in my country (therefore I'm an English teacher).

In English teaching there are 3 main methods (over simplified below) of teaching used here.

Method: Communicative Approach. Author: Noah Chomsky et al. -> Where you expose the student to a simple exercise and words and how to use them and then explains what happened and follow to more advanced exercises based on what is contained in the lesson (or to what you just explained). {It can be done starting with the mother language and then moving to the language one desires to learn as you progress in the classes, or classes can be taught entirely in the second language with a special care with the words used for beginners.}

Method: NLP (Neuro Linguistics Programmming). Author: Various -> You expose the student to a simple set of words translated, for instance verbs, and asks them to translate from their mother language to the language they are learning. Moving on to vocabulary and so on. On each lesson stacking how to use the verbs, vocabulary, expressions and some grammar (usually in this order).

Method: Immersion. Author: Krassner et al -> The student is taught, much like Communicative Approach but classes are done fully in the language and in a place where the person lives a routine with the language. To learn English (or any other language as a matter of fact) like this, according to the method, one would have to live in an English speaking country.

========================================================================= Edit: I believe this line is causing a bit of a confusion

I did not meant that Learning a human language is the same as learning a programming language. I'm just saying that, in English language teaching we have methods to do that, as listed above. Does CS have one (or many)?

---

Continuation of the original text:

-> Part I believe is causing confusion:

So above I believed to have expressed what I meant with "What are the pedagogical methods for teaching programming?" Making a parallel with Teaching English as a Second Language in order to __illustrate__.

I think from here things were well understood. Why do I ask this? And what answers I don't expect seeing.

What I see is that people usually say; "In this site, there is a very good teacher, or resources for learning how to code. You can use it." As a way to mirror that, to teach someone or a group how to code instead of pointing to a (or various) method(s)

That is not my question. It is very clear. What are the methods for teaching programming?

====!And not; What are the methods for learning how to code?!========

I hope this can help me, because I haven't really found an answer to this. Or at least not as explicit and detailed as I see in other areas of the teaching world.

I don't need a detailed explanation but if you wish to provide something more elaborated I will be thankful. Nevertheless the method(s) is(are) just fine and what I'm looking for.

Have a great day.

Note: Originally asked in -> https://stackoverflow.com/questions/50586854/what-are-the-pedagogical-methods-for-teaching-programming?noredirect=1#comment88194521_50586854

Answer 1

Inquiry-Based Learning is a great framework to use with teaching programming. It involves letting students build their own knowledge by exploring and questioning programming phenomena. For example, you may give students a boilerplate but of code, and ask them to make changes or accomplish certain tasks from the beginning point. Students should do some practice and research, and also participate in discussion and sharing of the programming they are doing. Ideally this is done as a community and students can form their own type of 'schema' for what they are learning, and learn, much as real programmers do, from one another. Learn more here; https://en.wikipedia.org/wiki/Inquiry-based_learning.

Personally, with I blend this method with several other in the curriculum I create, to create more scaffolding, instead of throwing them in the deep end with a problem. I find that students need a bit of direct instruction first, then can be given an inquiry & project based lesson.

Step 1- teach CS and programming concepts. Blend CS concepts with a programming language. Step 2- Show students an example of how to create a program, but place it in the context of the CS concept. For example, you may teach about HTML tags, then teach about how the internet came to be, and what the first markup language was intended to do. Students can create a website about the 'first internet'

Step 3- Inquiry-Based lesson. Give students a boilerplate activity, and pose some questions. How can we create a more efficient piece of code, using what you learned? Perhaps in an earlier lesson, you modeled researching on MDN, then using that for ideas and clarification. You may, for example, give them a programming concept and ask kids how to more elegantly create this code with the control structures and methods you have taught. Students should be creating and communicating among one another, and creating different iterations of the same code- again, this is a skill you have scaffolded and taught in earlier lessons as well.

Answer 2

I'm not sure this is what you are looking for, but from personal experience (and probably in no way 'official' educational paths) :

I gave each approach a name in order to be able to seperate them in case users want to discuss them.

• Frontal Theory: Speak in-class about constructs and syntax, students code at home (exercises).
• Collaborative: students and teacher code together in-class
• Guide-and-Release: Introduce them to the topic of coding in-class, then let them complete online-courses (there are lots of websites which provide virtual classrooms with a "control" function for the teacher observing the students' progress.)
• Project based: Each student / group of students decide in the beginning what kind of software (scale is up to them/teacher) they want to write / rebuild (e.g. a blogging site / a tic tac toe game in the command console). The teacher helps students research what is necessary for it, how to approach it. Learning progress happens throughout the development.

@Project based: example for the tic tac toe game: we need input, output, a way to store values, loops. Then start with researching&learning how input/output works in the chosen language. Gradually build up knowledge until the game can be implemented. (Probably my favorite approach, as it focuses on learning how to analzye/break down a problem, solve small instances one at a time and then put components / partial solutions together - which is coding at its core in my opinion)

Edit: Removed the following approach from above, as it is rather a didactical approach and not on the same "educational level" the previously mentioned - but for completeness, here you go:

• Free Style: Students learn by themselves in-class, the teacher is only available as a "helping hand" if problems come up. (No solution on a silver platter, but rather giving points on where a solution can be found - stackoverflow, documentations etc.)

Answer 3

To come to an understanding of this question requires some background. To teach "programming" (rather than computer science in general) we teach some language, say Java. But we use language quite differently than we use natural languages (Portuguese, English, ...). Both are used for communication. It is too frequently forgotten than programming languages are given certain characteristics to enhance communication between humans, so don't get the idea that programming languages are just (or even primarily) about communicating to machines.

However, Computer Science, is, at base, more like an Engineering discipline than it is like the Humanities. In CS we build things. If I leave out Computer Engineering, CS is mostly about building virtual things. As such we are less bound, though not unbound, by the constraints of physics. But we use programming languages to construct things in virtual worlds. It is true, of course, that a speaker of a natural language, think a poet, also constructs things, but those things don't actually have a real (i.e. direct) effect on the real world. But programs actually do affect the real world. The software system that enables this post enables a form of communication that didn't exist prior to its creation. Fernando Pessoa, while an incredibly creative poet, has had little direct affect outside the minds of aficionados.

The other main difference between the use of natural language and the use of programming languages is that the constructs of, again Java, are intended explicitly to extend the language, rather than to use it as is. Computer programmers create new words and give them meaning (classes, methods, interfaces, ...). Natural language speakers do so also, of course, but only incidentally and not as the main thing. On the other hand, if a poet adds a word to the language, that word is intended to be used universally with the meaning give. When we define new words (abstractions) in computing, those words only have local meaning, though some escape into the wider world of computing. Thus "account" has no universal meaning, but "linked list" does.

So, at the lowest level of pedagogy, we do, in fact, present simple examples and fairly concrete explanations of the elements of a programming language, but that is never enough for understanding. For a true understanding, the student has to create increasing complex virtual worlds, learning how to use the base language as well as its programmer-defined extensions to build yet higher level constructs. We call this abstraction and it is fundamental to what we do.

But fundamental to the understanding of teaching computer programming is the idea that the consequences of the various low-level constructs is far from obvious, either in meaning or in use. Computing languages need to be complete (Turing Complete) enabling any computable action to be written. But they also tend to be rather sparse. The language may be tiny (see Lisp, for example), but the possibilities are endless.

If students never understand how to create new abstractions they cannot be successful as programmers. In the earliest days of computing (before real languages were created) this was seen as a fundamental limitation, and everything since has led to enabling higher and higher level abstraction. This is independent of paradigm, by the way and is equally true for Functional Programming, Imperative Programming, Object-Oriented Programming, etc. Even Assembly Language permits some simple abstractions, but since it is limited we tend to avoid it unless other considerations make its use essential.

Imagine, for example, trying to express everything in English using the one thousand most frequently used words. It would be very difficult. However, if you already had a mechanism for creating new words from old, you would have a way to extend the language. Actually, we have that. It is called a Dictionary.

So, the main pedagogical tool we use in teaching programming is not explanation and example, but practice in creating complex virtual worlds. Much of the rest of CS, by the way, is related to this in some way as it enables this engineering goal. Database, Algorithms, Web Design, ... all give tools (at high levels of abstraction) that enable the creation of these worlds that affect the real world in fundamental ways.

This technique is called Active Learning and is used in many disciplines. There is a book on Pedagogical Patterns as used in computing that discusses many aspects of Active Learning and other relevant techniques.

There is an ethical consideration also. If a Poet says terrible things it rarely affects the lives of people, though I admit it is possible. But if a software designer creates an evil, for example, social meet up application it can have devastating real world consequences. One obvious example is that it is now possible for a computer virus to infect the control systems for electrical transmission infrastructure. If deployed, they could shut off the "grid", actually killing people (say in hospitals) that depend on a continuous electric supply.

So, the short version, is that we ask students to build things. We ask them to build complex things on the top of simpler things. Then we ask them to build even more complex things on top of that. Etc. Etc. Etc. There is no end. At each level we ask them to extend the language with carefully defined "words" (defining classes, etc). But it is for engineering, not for expression.

In this, teaching programming is much more like teaching Creative Writing, than it is like teaching a person a second language. In Creative Writing, the student writes increasingly sophisticated and complex things. But the pedagogy is mostly to encourage practice and the deepening of the understanding of the possibilities.

In fact, one technique used in teaching Creative Writing is simply reading the literature critically. Sadly, this is underused (by most) in teaching programming, but that is largely due to the absence of a recognized programming Literature. There are a few examples, such as Per Brinch Hansen's book On Pascal Compilers. But most programs, even quite sophisticated ones don't really count as literature.