
On the foolishness of “natural language programming” - LiveTheDream
https://www.cs.utexas.edu/users/EWD/transcriptions/EWD06xx/EWD667.html
======
kyllo
The hardest part about software always has been, and probably always be,
getting humans to first know and then express _exactly_ what they want.
Natural human language allows for vague, abstract, and ambiguous expression
(not to mention the euphemisms, exaggerations, half-truths and outright lies).

Most people who have never written a computer program, have probably never
even been through the experience of having to express exactly what they want
someone or something else to do for them, in a specific and non-ambiguous
manner. It really is a different way of thinking.

~~~
Kenji
Indeed. Not only that, but the power of a precise language is not to be
underestimated. I noticed that I had (and probably still have) a lot of
errorneous concepts in my head and the only way to find out the mistake is by
expressing them in a rigorous, formal language that forces you to think about
every detail, no matter how 'obvious' it appeared at first.

~~~
evilduck
Seems like software developers and lawyers share some common pains.

~~~
danbruc
I always marvel how our legal systems manage not to collapse given the
imprecise language they use. So while they have similar problems it seems to
me that they are just ignoring them for the moment and let somebody else
figure out what the precise meaning is if the necessity arises.

~~~
chillingeffect
Yes, in programming, the goal is to communicate clearly to an indifferent
interpreter. In legal worlds, the goal is to express the intention while
excluding the maximum number of outsiders.

Why else does every coding language provide plain-language comments, but legal
documents do not?

In technology, the machine is a stand-in for a human relationship - the cell
phone app keeps track of restaurant ratings so people don't have to keep
asking one another. The code is a part of the system of distributing the power
in the form of information.

In the legal world, the intently obscure language is the means of hoarding and
securing the power.

W/r/t to legal systems collapsing, they're protected by guns and myths. The
baillifs and police believe Columbus was a hero and they kill to uphold his
dream. The incentive to power is enough to entice enough new scholars each
year to sustain the illusion.

So to respond to the poster above, the pains of the programmer and legal
system are no more similar than the programmer and the chef. Each attempts to
communicate a procedure, but the legal system has an entirely different and
less noble set of requirements.

~~~
vinceguidry
> W/r/t to legal systems collapsing, they're protected by guns and myths.

This is true enough in many parts of the world, but a careful reading of the
history of English Common Law reveals a fascinatingly iterative legal process
that formed a bulwark against monarchal oppression for hundreds of years.

For a good introduction, check out this book:

[http://www.amazon.com/Inventing-Freedom-English-Speaking-
Peo...](http://www.amazon.com/Inventing-Freedom-English-Speaking-Peoples-
Modern-ebook/dp/B00BATKSIO)

~~~
pessimizer
Through a lot of blood, deaths, public executions, and religious declarations,
schisms and wars (civil and otherwise.)

The history of English common law is far more akin to natural evolution than
any intelligent design.

~~~
baddox
Which is interesting, because the vast majority of people (including and
perhaps especially those who reject intelligent design in biology) think that
a relatively stable and successful society and economy can only exist when
organized by a centrally and deliberately planned body called government.
That's essentially the "intelligent design" belief for human societies.

~~~
notahacker
If you believe that intelligence is the product of natural selection, and also
observe that nature has _very strongly selected for_ human social organization
under a government, it's far from unreasonable to use the advantage of the
intelligence we've evolved to augment the advantages of the governments we've
evolved.

~~~
lutusp
Natural selection often creates a relationship between predator and prey that
looks red in tooth and claw -- bears and salmon, wolves and elk, etc.. No one
will argue that the wolf represents an advantage to any individual elk, but to
the elk genotype, the argument can be made that the wolf confers an advantage.

It's the same with governments and people -- history proves that relationship
red in tooth and claw as well. The surviving elk outrun the wolves, and the
surviving people stay one step ahead of predatory governments.

When Stalin signed the non-aggression pact with Hitler, he began a purge of
his military. Anyone who had spoken against Hitler beforehand was purged --
shot or sent to Siberia. Then, when Hitler broke the pact and invaded Russia,
all those officers who had spoken in Hitler's favor were purged. The survivors
were those few who didn't have an opinion, or who didn't dare express it.

The Cultural Revolution in China purged all those bourgeois elitists who had a
college degree or who had acquired skills like science and technology, or any
significant academic achievement. Now everything has changed and individual
Chinese are allowed -- nay, encouraged -- to educate themselves for success,
acquire wealth, and grow the economy -- exactly the opposite of the Cultural
Revolution outlook. It is a very wise person who avoided any problems during
the Cultural Revolution, and who avoid any problems now.

My point? Elk who survive do so by avoiding wolves. People who survive do so
by avoiding governments. It's true that wolves improve the genetic stock of
elk, just as governments improve the genetic stock of people, and by the same
method -- by tearing the weak and sick to pieces.

------
scoofy
Graduate of analytic philosophy here (concentrating in philosophy of
language), and my take away is a sloppy: "It's not a bug, it's a feature."

Sorry, but this is a completely shocking article to me. First in it's
immediate dismissal of any formalism inherent in natural language, but also
with the ease at which he dismisses the proposition without any real
consideration.

If we learned anything from Chomsky, it's that the underlying grammar we are
born with is both instinctual, and follows formal rules. To say differently is
literally, demonstrably false. Irregular verbs, for example, aren't learned in
the traditional sense, one must actually unlearn the formal rules. Any child
that tells you she "swimmed" all afternoon is using a more formal version of
English than you do.

The idea of a natural language programming language is flawed, but not by
formalism. It's flawed by the evolutionary nature of natural languages. That
is, the very people that he states "are no longer able to use their native
tongue effectively," are probably using a new dialect that shares a common
ancestor with his more "traditional" usage.

Many people in this thread are talking about the inability of plebes to
express what they actually want. This is a fair point, but not a problem with
language specifically. Communication tools would need to be employed by a
computer in the same way as humans use them. E.g., a simple ambiguity checker
could work wonders here, as it does between humans when someone you are
talking to simply says, "What did you mean when you said you 'realized you
forgot your phone at the train station'? Did you forget at the train station,
or realize at the train station?".

What IS a problem, however, is Quine's indeterminacy of translation. That
could pose serious hurdles that may be insurmountable, however, we still have
effective communication between humans, so it's simple to see how this may
only be a theoretical problem, rather than a formal one.

This subject should be under the purview of analytic philosophy and
linguistics, not mathematics or computer science.

~~~
305b283f
Agreed.

It seems an appalling number of people agree with Dijkstra here - "we not only
don't need natural language, we don't even want it."

I'm sorry, but if I can express to a human being a set of directions to fill
out a form in a minute or two and expressing that to a computer takes much
longer and is more error-prone, _that is an inefficiency in software
development which it is extremely desirable to address._

There is nothing magical about human brains that would make them theoretically
impossible to express in software in such a way that we can give a program
natural language directions, and the fact that so many people want to dismiss
this endeavor out of hand is ridiculous to me.

This should be our holy grail, something to strive toward, not something to
ignore.

In fact I would suggest that it will most likely be the only way out of the
mess of such a wide variety of software standards (ever have fun moving your
things to a new system and having to re-learn many things just because you
changed PC or phone operating systems?), whereas natural language is a
standard we already have and works fine.

This way you essentially wouldn't need to learn a new set of incantations -
just tell the damn thing what you want the damn thing to do, dammit.

~~~
phkahler
>> This way you essentially wouldn't need to learn a new set of incantations -
just tell the damn thing what you want the damn thing to do, dammit.

I'm going to guess that you've never given a set of requirements to a
programmer before. Programmers ARE the human interface to computers, as they
are often writing software to specifications created by someone else. Many of
the problems arise in the ambiguity of the human-human communication. Another
part comes from the lack of specificity combined with different ideas about
how to handle unspecified cases. Your idea of what is obvious is not the only
one. Some people lack domain knowledge that is assumed in requirements and
leads to poor choices where specifications are not complete. In the end,
natural language assumes a broad swath of "common sense" that computers do not
have yet.

~~~
305b283f
I'll respond to your points, but was the ad-hominem really necessary?

> In the end, natural language assumes a broad swath of "common sense" that
> computers do not have yet.

Absolutely. I'm not at all saying that we'd have had this last Tuesday if we'd
just take our heads out of our asses - I'm saying it's something we should
strive toward and not ignore.

> Many of the problems arise in the ambiguity of the human-human
> communication.

Human-Human communication works, and works well - once again, _we do it every
single day, all the time._

Do we encounter problems with ambiguity? Sure. But they are by far the
exception and not the norm. After all, forms get filled out, Driver's licenses
get renewed, complicated Starbucks orders get filled - these common use cases
_work_.

By contrast, have you ever had this fun experience with a terminal program?

> quit

Unknown command: "quit"

> exit

Unknown command: "exit"

> shutdown

Unknown command: "shutdown"

or my favorite:

> quit

Unknown command "quit." If you want to close the program, type "exit."

Simple English statements like these work extremely well in human-human
communication and do not work hardly at all in human-computer communication.
I'd just like us to get from A to B, that's all.

------
bsenftner
I've been working with a natural language conversational agent for the last
few months, creating a simulated personality from a novel, as a promotion for
the novel. Natural language opens up a huge host of unreasonable expectations
from the user, but more interesting is the utter gibberish people enter
thinking they are conversing. When I say utter gibberish, that is exactly what
people enter: sentence fragments with no subject, no verb and no correct
spellings outside of "a", even "the" is most often spelled "teh". I suspect
"natural language" makes people relax, but even when we hook in ASR (automated
speech recognition) to get away from the gibberish spellings, the "sentences"
people enter do not make sense. To some degree, I believe people are testing
the limits of the natural language and knowledge base backing it, but too many
of the "conversations" reveal an expectation of unreal super knowledge, like
"you should know what I'm hinting, even though I can't spell or describe it"

~~~
TheLoneWolfling
Sounds a lot like SMS conversations.

It might as well be a different language in a lot of ways.

------
canjobear
It's sad to see him buying into this silliness:

> Remark. As a result of the educational trend away from intellectual
> discipline, the last decades have shown in the Western world a sharp decline
> of people's mastery of their own language: many people that by the standards
> of a previous generation should know better, are no longer able to use their
> native tongue effectively, even for purposes for which it is pretty
> adequate.

~~~
shubb
When people gain a certain authority by being very smart in a narrow field,
they often use it to talk about the problems of society in general.

Because though they are an expert in their small field, but no more informed
or unbiased than your friend at the pub, they end up sounding dumb.

In this and some of other writings, he would do well to think and gather data
about social issues, or talk mostly about algorithms.

~~~
jodrellblank
All sorts of people talk about all sorts of things.

When someone who is famous talks about all sorts of things, it's fashionable
to diss and mock them for "speaking outside their authority", yet everyone
else is free to ramble about whatever they like.

You're doing an inverse arugment by authority here; "whatever Dijkstra says
about [not-programming] is wrong and should not be listened to, because of who
the speaker is".

~~~
shubb
Yeah, but he seems to be predicting the decline and fall of western
civilisation because of unspecific use of language by young people these days.
As there is no single definition of western civilisation, this is ironic as
well as dumb.

The man in the pub may have a good point. If you read Djikstra's other essays
where he wanders off subject, you'll motice he rarely does. He sounds like an
angry old man, lost in dreams of a better past that never was.

------
why-el
Dijkstra is right, and this has been a standard problem in philosophy and
logic. Only when one considers programming to be some new endeavor divorced
from its logical roots that this problem seems new and puzzling. For more,
check Russell's Theory of Definite Descriptions.

~~~
scoofy
I'm not sure i follow. The problem of definite descriptions has more to do
with reference in the external world. I'm not sure i see how it would be a
problem with the limited scope of a formal framework in a programming
language.

When you're dealing with variables, "morning star" "evening star" problems are
essentially irrelevant because you are defining things, rather than merely
naming them.

~~~
pessimizer
You're still naming things, they're just _things in a computer_ that you have
to carefully specify so that they behave like their real-world referents
within your model (also in a computer.)

'Morning'/'Evening' star won't matter until it does - and if it were something
that wouldn't ever matter, you probably wouldn't have input it.

~~~
scoofy
But the framework is completely different. In nature, we must have an
inductive framework. We will observe phenomena, and name. With computers, we
are doing something very different. The framework is deductive, thus we do not
name, we define.

With naming, we can be wrong, because of the inherent negative knowledge of
our framework. That is, in science, we can only prove with certainty that
things aren't the case, not that things are. This is Karl Popper thesis.

With defining, we cannot be wrong about things, we have the ability to have
perfect knowledge, so the things we are referring to are defined to be such,
we simply cannot be wrong about their identity and structure.

------
tree_of_item
Dijkstra is wrong on this one. Siri and Cortana have already achieved this for
trivial classes of programs, and they will only improve.

People comparing natural language programming to EULAs are missing the point
entirely: natural language input guides a search process for formal programs,
it isn't literally "the program" itself.

~~~
tel
I think Djikstra would not be bothered by this. His arguments tend to be that
even with such a search process it's the very providence of formal language to
give someone the power to guide that search.

In other words, you'd need formal language to be able to specify what you
truly want, then would "translate" it to natural language to execute the
search, the processor would search for the proper formal language expression,
and then you would verify.

Or you could just skip all the intermediate steps.

~~~
tree_of_item
It's the developers of agents like Siri and Cortana, not the users, who need
formal language.

Anyway I don't think we're disagreeing with each other: there is always going
to be a place for formal languages, they won't ever go away and be "replaced"
with natural language interfaces, it's just that Jane Random will be more than
happy to speak some gibberish to her computer and let the machine figure
things out.

~~~
tel
Oh but we are: I don't think Jane Random will ever reach so far into that
direction until her desires become vastly simplified. So in a Wall-e style
future then yes, but in one where people still do things creatively there will
always be need for formality.

------
ar7hur
Natural language is ambiguous: one phrase often has multiple meanings. That’s
the result of many thousands of years of evolution, and it’s actually very
efficient. If we had to be always explicit, our phrases and sentences would be
much, much longer — and boring. When A says something to B, A makes
assumptions on B’s context, common sense,beliefs and knowledge. The verbal
message itself just contains the minimum information needed, on top of this
pre existing information, in order for B to get it.

Natural Language can be seen as a very efficient compression algorithm. The
phrase the speaker chooses is the shortest message, given the context of the
receiver.

Programming a computer with Natural Language is incredibly difficult, because
Natural Language alone, without the context it is built upon, really lacks
much of the information the computer needs to operate the program.

------
falcolas
All I can picture coming from this is reams of EULAs.

Legal documents contain the most precise language we humans can create that
can still be considered to be "natural", and they're still all but unreadable
without the proper degree and legal context.

Not precisely what I would call a "win" for the ease of programming

~~~
josephschmoe
Consider that programming doesn't have to be linear - while legal documents
need to be printed on a piece of paper. Granted, they have limited non-
linearity (references to prior pages, pointers, etc.) but it generally has to
be readable on physical paper.

For natural language programming to work, computers simply need to be capable
of making prudent guesses - so long as we show the information clearly, we can
always fix those guesses. We can allow for limited instances of constructed
languages, rewiring connections between words, etc.

~~~
falcolas
Legal documents are just as referential as programs are - their function calls
are simply defined in a natural way, i.e. "Except for S6.6, S8.2, and S10.2,
the test samples are stabilized at test room temperature prior to testing.",
or "The following terms of service and end user license agreement (“EULA”)
constitute an agreement between you and Rovio Entertainment Ltd, and its
affiliates (“Rovio”). ".

You mention that such references are limited in nature, but laws are rarely as
limited in their references as EULAs are. Plus, there's a whole layer of
context which exists outside the written document - the exact legal definition
of words.

I just don't think that a "prudent" guess will be enough, especially as you
start distributing such programs to machines or situations where the context
is different.

------
malisper
Dijkstra clearly points out that it would be impossible to program in a
_natural_ language. The thing is there are _constructed_ languages such as
Lojban[0]. Lojban, while semantically ambiguous, is grammatically unambiguous.
This means a computer can understand something said in Lojban, but a computer
cannot perfectly understand what is meant. While I'm no expert, I'm pretty
sure it would not be very hard to create a computer interface using Lojban.
I'm curious as to if anyone can explain why this is or isn't feasible.

[0] [http://www.lojban.org/tiki/Lojban](http://www.lojban.org/tiki/Lojban)

~~~
rwallace
That wouldn't help significantly, because the hard part of getting a computer
to understand instructions in English isn't understanding English, it's
understanding the universe.

Suppose you want a robot you can give instructions like "clean the kitchen".
Programming the robot to understand this as performing the action 'clean' on
the object 'kitchen' is something we can already do. The problem is that the
robot doesn't know _how_ to perform that task. It doesn't even know what what
state of affairs constitutes the desirable end result of a clean kitchen (as
opposed to e.g. an empty kitchen because it threw out all your food and
cutlery along with the trash). That knowledge is the meat of the problem, and
it's just as hard in any language.

------
mcguire
For some reason, Dijkstra quoting A.E. Houseman brightens my day. And then
there's this:

" _Therefore, although changing to communication between machine and man
conducted in the latter 's native tongue would greatly increase the machine's
burden, we have to challenge the assumption that this would simplify man's
life._"

------
todd8
I've noticed the limitation of natural language frequently. Sometimes, its
just the inability of natural language to deal with levels of abstraction
precisely. Sometimes, its the large assumed domain context that accompanies
the use of natural language when describing procedures.

I had clients once where both of these limitations prevented us from being
able to produce a product for them. They where incredibly successful Wall
Street types. They wanted a software system written that would automate some
of what they did. They were traders, but not interested in high velocity
trading. After a weeks of meetings about high level goals, we had a meeting to
finally get down to specifics about the procedures and functionality that they
wanted. They simply couldn't describe in precise language what they did! They
had been doing it for years and years very successfully, but we couldn't help
them because they couldn't describe what they did. It was very odd.

They worked with sophisticated mathematical models and strange rules of thumb,
the morning news, and the perceived level of activity on the exchange floor.
Some of them used fancy interactive graphs while others relied on a simple
printout of a spreadsheet full of numbers.

The universe they worked in was very complex and involved decision making
that, apparently, was hard to describe in words. Imaging a world class boxer
trying to put into words the algorithm that he used to win a match. It was a
bit like that.

------
jdmichal
There is a joke that perfectly illustrates this entire article:

A programmers wife asks him, "Please go to the store and buy a carton of milk,
and if they have eggs, buy a dozen."

The programmer returns home, and his wife is very angry with him. "Why did you
buy twelve cartons of milk?!"

English SE question detailing the linguistic mechanisms:
[http://english.stackexchange.com/questions/40234/bring-6-egg...](http://english.stackexchange.com/questions/40234/bring-6-eggs-
if-there-are-potatoes-bring-9)

~~~
jiggy2011
Wouldn't this imply that the "buy" instruction is stateful?

~~~
andreasvc
No. It's just the implied object of the second "buy" which is ambiguous.

~~~
jiggy2011
But then the programmer would come home empty handed, without even buying the
milk.

------
davesque
This reminds me of when I first learned to program. By far the hardest part
was learning how to _think_ clearly and discretely. It changed the way I
looked at the world completely. Really, we should _want_ people to overcome
this challenge, not avoid it.

------
pjungwir
I saw the title and thought, "Oh good, someone else who thinks like Dijkstra!"
Oh well. :-)

I feel like the halting problem and Godel's theorem imply programmers will
never be out of a job, and the best we can do is build out more and more
solutions for specific use-cases, like Wordpress and Shopify. I don't think
there will ever be a general-purpose AI that can write computer programs. At
least not in my lifetime or my children's.

And btw, has anyone else felt that the Halting Problem and Godel's theorem are
two sides of the same coin? Is there any formal connection between them? I
feel like they are not "independent" (in the sense that Euclid's 5th postulate
is independent).

~~~
arketyp
>And btw, has anyone else felt that the Halting Problem and Godel's theorem
are two sides of the same coin? Is there any formal connection between them? I
feel like they are not "independent" (in the sense that Euclid's 5th postulate
is independent).

The theorem of the unsolvability of the halting problem is used in modern
proofs of Gödels incompletness teorem(s) [1]. Hofstadter writes about this
relation in Gödel Escher Bach as well.

[1] [http://www.amazon.com/Lectures-Logic-Set-Theory-
Mathematical...](http://www.amazon.com/Lectures-Logic-Set-Theory-
Mathematical/dp/0521168465)

------
sp332
This reminds me of Inform 7. The source code for the language is pretty much
plain English. I like this because programs are read more often than they are
written, and it's usually very easy to read a program and see what's going on.
But the syntax is still pretty limited, and it only understands certain ways
of expressing things. So you still have to learn the syntax and very specific
semantics, even though the language looks like English.

------
michaelvkpdx
If you use the same language to solve a problem as you use to describe the
problem and to define success, then your ability to accurately solve the
problem will be constrained by the level of precision that is available in the
language being used.

Given this- natural language programming can hope to achieve reasonable levels
of precision in very few languages. English, for example, has over a million
words, while French and Italian are both under 100K. That 10x discrepancy in
words means that there is necessarily far more imprecision in romance
languages than English. Graamatical constructs can add precision and clarity
but cannot make up for the inherent gap in vocabulary precision.

Someone with more knowledge can comment on the feasibility of precise NLP in
non-English, non-romance languages.

If, however, acceptance testing is defined through the precision of a low-
level programming language, but the problem is defined in a less-precise
natural language, there will always be a precision mismatch between the
languages used to define the problem. A solution may be implemented that
addresses the natural language issue but cannot meet the constraints of the
programming language.

------
mwfunk
Sometimes I wish that the term 'language' had never been used to describe the
blobs of text we use to create formal specifications for programs. This
invites all sorts of comparisons/analogies/metaphors to spoken and written
languages that may not necessarily be meaningful or constructive.

I think of source code as being more analogous to architectural blueprints or
formal logic than someone's verbal description of an object. It's just a
coincidence that source code is governed by structures and concepts that exist
in human languages.

Usually when people say they want to be able to create software with natural
language, what they want are better tools that allow them to more efficiently
create something, with less time spent worrying about syntax or technical
minutiae. This outcome doesn't require natural language, it just requires
better tools.

------
tim333
I kind of disagree with the article and would like to be able to use natural
language. The fact that computers are currently too dumb to understand English
is an issue but not the one the author seems to be going on about. One of the
reasons I like Python is it reads rather like English making code easy to
understand and one of the main reasons for Lisp not really taking off is its
reading so unlike natural languages makes it hard to understand. The
comparison with maths seems false to me - many mathematical concepts express
very badly in English and elegantly in mathematical symbolism - complex
numbers, path integrals and all that. There seems little with that kind of
complexity in computer science it's all add this, write this to the database,
draw this on the screen etc.

~~~
markbnj
I think you missed Dijkstra's point. Why don't we use "natural language" to
reason about mathematics, physics, logic, or even the structure of language
itself?

~~~
tim333
Possibly. We do in fact use natural language to reason about mathematics and
physics - if you look at any text book it's about 90% english words and 10%
equations. But I'll give you the equations are important and powerful in math
and physics but I'd argue less so in computer programming.

------
josephschmoe
This article is an Appeal to Novelty fallacy. He never gives a reason why
explicit language is better - just that it occurred later in civilization.

Beyond this, natural language programming doesn't preclude explicitness. You
could still have portions of limited explicit language or even portions of
actual code if that is insufficient.

Natural language programming gets us two advantages:

1\. Easy entry (presumably what the author cares about)

2\. A language which is composed of an infinite number of DSLs - but without
the pains of limited language scope and in which DSLs are actually easy to
write. This actually fixes the problem author was taking about - using a
language for a purpose it clearly wasn't meant to.

And if you think natural language programming is going to get rid of symbolism
in language, I've got a U+1F309 to sell you.

------
cramerica
The problem is of course the vagueness in natural languages caused by the
complexity of its grammar and the unstated contextual nature of it all.

"The black truck driver ran through the red light."

Is the truck black or is the truck driver black?

Is the driver driving, or is he running on foot?

Is the red light a traffic indicator, or is it a just a beam of red light?

Teaching a computer to figure out the intended interpretation here is a
monumental task, and teaching the people to understand how their use of
language is actually very easy to misunderstand is even harder.

~~~
Qantourisc
Indeed, but figuring this out is trick

In Western countries you'd assume it's a black driver. In a country where
almost everyone is black you'd assume a black truck. So the code could have
bugs depending on the location/culture (and thus context).

------
Grue3
The counterpoint would be Inform 7 [1], a natural language-based programming
language for interactive fiction.

[1] [http://inform7.com/](http://inform7.com/)

~~~
the_af
Inform is a formal language with precise disambiguation mechanisms that
natural language doesn't have.

The goal is not simply to replace curly braces and other symbols with English
words; unlike what COBOL would have us think, that road doesn't lead to
natural language at all.

------
LeicaLatte
I like that Dijkstra used the word foolish.

As someone who has interacted with Google, Microsoft and Apple's natural
language systems I am glad this was ignored. Happy someone stayed hungry.

~~~
barrkel
In another comment, I compared the process of making computers do our will to
manipulating a lever, the lever being made out of abstractions.

What Google, MS and Apple's NLP systems are doing is mapping your words to a
selection of pre-prepared levers. It's simplistic in the extreme compared to
the real problem of being able to create new levers.

IMO, in dismissing Dijkstra, you completely missed his point.

~~~
LeicaLatte
Don't see any levers in the article lol I have no clue of what u saying sorry

I definitely think the aspiration for natural language programming has only
made things better and something we all look forward to

------
Uncompetative
Anything open to ambiguity can be resolved through dialogue.

------
skywhopper
That was a good article, and I agree with his take about the value of using
natural language to program computers. However, the last, and unnecessary,
"remark" undermines the entire essay by revealing a profound misunderstanding
of the nature of human language, thereby placing himself firmly into the
irrelevant crank category in the minds of many potential readers.

------
JabavuAdams
What this misses is that it can be useful to structure design as a
conversation, rather than a monologue.

We often make this mistake with computer systems. I.e. the need to specify
everything up front. Imagine a workflow where the process of design is a
conversation with the system. To some extent, REPLs capture this, but they're
still driven wholly by the programmers.

------
nebstrebor
The same could be said of "natural language contracts" and "natural language
laws and regulations". Lawyers get hounded for "legalese" but its just a form
of code--based on but deviated from natural language--to try to overcome the
inherent inefficiencies of natural language.

------
avens19
This is my favorite part of software engineering. The fact that there are so
few instructions you can actually give the machine and that you have to map
your abstract ideas onto those instructions

------
thisjepisje
Meanwhile we have things like Wolfram Alpha and Google search trying to
process natural language in the place of more code-like input.

------
hyp0
see also natural language maths and natural language law.

though, to be fair, eliminating useless jargon _is_ helpful, but you've got to
keep the useful jargon.

