I came up with an idea about a programming language or environment to teach programming concepts.
The language is meant to allow students to learn at whatever pace they want. Though it would never act quite like a real language, as it would all be managed and used through a UI rather than through typing code, it should be able to progressively express the different concepts in computer program design. The advanced features should always be present, but also transparent; this way, they will not distract students from what they are learning, but will also not hinder them if they want to learn more.
The first "program" a student would make would consist solely of dragging an "instruction" (what we programmers tend to call a function) to the "story" (function main). This instruction would probably be something to the effect of "Show a picture on the screen" or "Show a line of text on the screen." The students would then pick a picture to show or type in a line of text to write.
Then, students would create their own instructions. Of course, this should be done through a nice, big, green "Create an Instruction" button with a pretty graphic in it. Into this instruction, they can drag other instructions. Then, clue them in to the fact that they can drag other instructions of their own creation into their custom constructions.
After learning about custom instructions, they'd be introduced very simply to parameters. Of course, they would have already used parameters while printing lines on a screen! So they already know what they are - they just have to make their own now. So, they would, in their instruction creator, click "add parameter". Now, the trickier part for me to find a way to explain so simply: how to use these parameters.
Most likely, a student could use a parameter by simply selecting any of the instructions they use within their own instruction and, instead of supplying a value in a "hard-coded" fashion, say "Use the value of a parameter:", and magically, the parameters would be listed. Perhaps there is a simpler way to demonstrate this, I'm not sure.
Variables still should not be introduced. Those should come later. First, the concept of "objects" should come into play
Objects in story language would be similar to objects in object-oriented programming languages, only, by default, they'd lack a type. Instead, students would simply create an object (with a nice big "Create Object" button), then name them (perhaps the name of a friend), then add "attributes." (Perhaps hair color, etc). Finally, they'd add "instructions," which are exactly like custom instructions, except they are ones that apply to the specific object.
Their first project with objects could be to create ones for each of their friends. For instance, a student might create an object named "Sarah." She would have an "Eye Color" set to brown, a "Hair Color" of purple, and a "Full Name" of "Sarah Wilkins." The student might then add an instruction "Walk the Dog." The instruction would call the "Print a line" function, supplying the attribute "Full Name" to the parameter of what to print, so as to print (with multiple calls to the print line instruction) "Sarah Wilkins walked the dog!"
To use their object, they would "introduce" them in their story (the main function, remember). They could then call their objects' instructions like any other instructions, only, they'd be "talking" to the object. This would teach the difference between member functions and global functions.
After objects, "groups" would be introduced. Simply, groups would be objects themselves. Students might be taught to create objects called "Humans," "Friends," and "Family." First, of course, they'd create "Human." They'd simply make an object named "Human," add an attribute for full name, maybe birthday or hair color, and add a few instructions - whatever they feel like.
Then, they'd create an object "Friend." Here they would do something special. They'd set their object to "Human" by clicking "Add To Group" (which should, again, be a big nice easy-to-read button). All of the instructions and attributes of "Human" would immediately apply to their new Friend object. They then might add another instruction, such as "Play!", which could write out the friend's name, followed by " is Playing!" (much like when objects were introduced in the first place)
And thus, inheritance is taught!
At this point, perhaps, variables should be introduced. In fact, they should be introduced as already having been introduced. This kind of self-evident introduction of new concepts should be used frequently, as it will boost the students spirits at having already practically known, without realizing it, what they were about to be taught. Parameters to functions and attributes of objects are variables! And now, students just need to press "New Variable," and they'll have one. They can pick, is it text, or an image? Or, is it an object? They can create variables of type "Human," or "Friend"!
Alas, at this point, I've not thought fully enough as to what comes next. It is late, and I need to be getting to bed. Perhaps later I'll flesh out the idea a bit more, but for now, this is it. I hope you have enjoyed reading this as much as I have enjoyed thinking it!