"Make it possible for programmers to write in English and you will find the programmers cannot write in English."
I teach computer science and have a particular fondness for introductory CS. The reason Stephen Wolfram is wrong, wrong, wrong about this is that people that have never been taught programming can't express themselves precisely enough in their native language, either; and even among those of us that have been programming for decades, when we express ourselves in natural language we can be very precise but it takes a lot more work and becomes a lot more unwieldy than just writing out our instructions in [pseudo]code.
CS educators have been wishing for a long time that "intro to CS" didn't equate to "intro to programming". And it doesn't have to, not quite, but the reason it always seems to revert there is that the prerequisite for every other thing in CS is, not programming itself, but a certain precision of thought that is easiest to teach just by teaching students to program. In a programming language. Because if you try to make them write out instructions in a natural language, and you notice that they aren't being precise and therefore deliberately misinterpret that instruction, they just think you're being a dick about it. They sometimes even think this if you honestly misinterpret them. (This is true even in a non-CS context.)
Saying that we will soon be "generating code from natural language" is, at best, misleading. It implies that people who couldn't learn a programming language will be able to program, which is quite untrue---I promise that with the possible rare exception of a few pathological edge cases, when people can't learn to program, the language is the least of their problems. And for those of us that can and do learn programming languages, all but the simplest sorts of programs will probably be easier to write in a programming language (which was designed for that sort of thing) than in a natural language (which was not).
(And holding up Mathematica as an exemplar is particularly egregious; it is so loaded with syntax that "just works" that you need to either have a deep familiarity with traditional mathematical notation or else a degree-level CS background in programming language theory if you want to have a good shot at learning the language in anything more than a pattern-matching fill-in-the-blank way.)
I know programming, and I find wolframalpha far more intuitive than the standard interface in mathematica because I need to remember less commands, and often I can just guess what should work.
With the interactive nature of this thing people are going to learn if they want, just as people learned to type grammarless queries into google.
I don't think the point of this is for random-street-smart-kid to program complex systems seamlessly, it's more for random-physics-loving-student to try out things he still doesn't understasnd, and stuff like that.
The problem with this analysis is that it discounts the possibility of interactivity. There are many who cannot think through the logical steps needed to complete a task, but can watch a system stepping through a task, stop it when it seems to go wrong, and provide an explanation as to what's wrong about it. There are a whole lot of problems for which this trial and error process would converge to a mostly working solution.
Hell, there are many programmers who code things this way - try it, change it, repeat. Natural language would just allow non-programmers who aren't familiar with the syntax to join in on this process. Continued practice would likely improve the reasoning abilities of the user and make the process faster.
I have no problem with this idea of iterative refinement, and indeed I actively teach it. There are certainly students who pick up the syntax more slowly, but this is largely a matter of degree. But the students I refer to above have trouble even identifying what's wrong about an intermediate value or where things went off the rails or what a correct answer would even look like. They're more common than you (as a hacker) would ever believe unless you teach intro CS. They can be taught at least enough to pass CS1, but it's not easy and "natural language programming" will not help them with the things they need help on. (Might actively hurt, actually.)
Agreed. Take any of the modern mainstream languages like Java or Python, for example. If you were to describe them to a non-programmer who didn't know what a programming language was, or why it was needed, you might say something like, "Well, they look a little like English and they use some of the same words from English. But they have very precise meanings which are not exactly the same as in English, and you can put them together in ways which are different than English, and the reason why is to be much more precise and explicit and concise than what you could do in English. And because a programming language has nothing to do with emotions or conveying concepts but instead in purely carrying out a sequence of steps and manipulating and storing data. That's it." In other words, their designer's started with a natural human langauge, then left out the parts that were irrelevant to the computer, then zoomed-in on and enhanced the richness of the expression capabilities when it comes to certain other areas. They threw out the bathwater and made the baby bigger and better! In other words, they were designed starting with the premise (or perhaps it was a conclusion you reach along the way) that so-called natural language programming is pointless or inefficient, and so they want and made another kind of programming, which worked much better. Their requirement was to make a machine that propels itself under water. They knew they were going to call it a submarine. They realized early on there was no need to make that submarine "swim" like a human. They just added propellors and rudders, etc. Making a submarine "swim" was irrelevant. It just had to move through water.
I teach computer science and have a particular fondness for introductory CS. The reason Stephen Wolfram is wrong, wrong, wrong about this is that people that have never been taught programming can't express themselves precisely enough in their native language, either; and even among those of us that have been programming for decades, when we express ourselves in natural language we can be very precise but it takes a lot more work and becomes a lot more unwieldy than just writing out our instructions in [pseudo]code.
CS educators have been wishing for a long time that "intro to CS" didn't equate to "intro to programming". And it doesn't have to, not quite, but the reason it always seems to revert there is that the prerequisite for every other thing in CS is, not programming itself, but a certain precision of thought that is easiest to teach just by teaching students to program. In a programming language. Because if you try to make them write out instructions in a natural language, and you notice that they aren't being precise and therefore deliberately misinterpret that instruction, they just think you're being a dick about it. They sometimes even think this if you honestly misinterpret them. (This is true even in a non-CS context.)
Saying that we will soon be "generating code from natural language" is, at best, misleading. It implies that people who couldn't learn a programming language will be able to program, which is quite untrue---I promise that with the possible rare exception of a few pathological edge cases, when people can't learn to program, the language is the least of their problems. And for those of us that can and do learn programming languages, all but the simplest sorts of programs will probably be easier to write in a programming language (which was designed for that sort of thing) than in a natural language (which was not).
(And holding up Mathematica as an exemplar is particularly egregious; it is so loaded with syntax that "just works" that you need to either have a deep familiarity with traditional mathematical notation or else a degree-level CS background in programming language theory if you want to have a good shot at learning the language in anything more than a pattern-matching fill-in-the-blank way.)