This exists. It's "Write each step of an algorithm in comments before writing any code, and (only when you're finished writing each step in English in comments) fill in the code each comment represents".

But it's impossible to convince anyone to try that, though, even though it gives all the benefits you are imagining NLP would give.

The mentality "Don't repeat yourself under any circumstances, even if it adds no complexity and increases clarity!" is unfortunately why this is undiscovered. Also, people generally go overboard with the "commenting" part -- the purpose is to be pseudocode in the way Python is executable pseudocode, while retaining the ambiguity that is necessary for natural language to be natural. So it gets a bad reputation, and its power is hidden despite it being powerful.

Here's an actual snippet of a test I wrote before writing the corresponding code for an app that's now in production:

  describe "adding participants" do                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   
    context "when user has created a new event" do
      before :each do
        visit root_path
        click_link 'Get Started'
        fill_in 'Name', :with => 'Tres'
        fill_in 'E-mail', :with => '[email protected]'
        click_button 'Next'
      end
    
      it "should prompt for more participant info" do
        page.should have_field 'Name'
        page.should have_field 'E-mail'
        page.should have_button 'Add Participant'
      end
    
      it "shouldn't let you enter an invalid e-mail" do
        fill_in 'Name', :with => 'Tres'
        fill_in 'E-mail', :with => '#)(*)($*#)($*'
        click_button 'Add Participant'
        page.should have_content 'invalid'
      end
    end
  end

It doesn't work so well 6 months later when you're editing that code.

[1]http://en.wikipedia.org/wiki/Controlled_natural_language

But I'll note that we humans manage to understand each other just fine without resorting to a controlled natural language. We solve the ambiguity problem basically by taking the most likely interpretation of a given sentence, given the context, or asking questions if too confused. And in fact, there are natural language parsers out there that can predict the mostly like parse reasonably well for single sentences.

The biggest problem here is that programmers like having full control of what's going on, whereas this sort of idea brings in a large dose of unpredictability: how will the parser interpret this sentence? I think this can be solved to some extent by having the parser tell you what it parsed in less ambiguous terms. In fact, you might ask the parser to present a normalized version of the code that is more specific about exactly what's going on (and probably more verbose), and also expanding out phrases to show you exactly what they mean for debugging purposes. Also, when a clear parse cannot be made, the parser can simply ask you to clarify, presenting the multiple parses that it could not decide between.

[1] http://en.wikipedia.org/wiki/Lojban

> There's even some work to encode legal knowledge using them

Where do I learn more about this? What's the name of that language, or research project, or...?