Is there a human readable programming language?

How about LOLCODE?

HAI
CAN HAS STDIO?
VISIBLE "HAI WORLD!"
KTHXBYE

Simplicity itself!

COBOL is a lot like that.

SET MYVAR TO 10.
EXECUTE MYMETHOD with 10, MYVAR.

Another sample from Wikipedia:

ADD YEARS TO AGE.
MULTIPLY PRICE BY QUANTITY GIVING COST.
SUBTRACT DISCOUNT FROM COST GIVING FINAL-COST.

Oddly enough though, despite its design to be readable as English, most programmers completely undermined this with bizarre naming conventions:

SET VAR_00_MYVAR_PIC99 TO 10.
EXECUTE PROC_10_MYMETHOD with 10, VAR_00_MYVAR_PIC99.

Inform 7

Inform 7 is perhaps the language I feel is most appropriately designed in a human language fashion. It is quite application specific for writing adventure games.

It is based on rule-based semantics, where you write a lot of rules describing the relationship between objects and their location. For instance, the section below is an Inform 7 program:

"Hello Deductible" by "I.F. Author"

The story headline is "An Interactive Example".

The Living Room is a room. "A comfortably furnished living room."
The Kitchen is north of the Living Room.
The Front Door is south of the Living Room.
The Front Door is a door. The Front Door is closed and locked.

The insurance salesman is a man in the Living Room. The description is "An insurance salesman in a tacky polyester suit. He seems eager to speak to you." Understand "man" as the insurance salesman.

A briefcase is carried by the insurance salesman. The description is "A slightly worn, black briefcase."  Understand "case" as the briefcase.

The insurance paperwork is in the briefcase. The description is "Page after page of small legalese." Understand "papers" or "documents" or "forms" as the paperwork.

Instead of listening to the insurance salesman: 
    say "The salesman bores you with a discussion of life  insurance policies.  From his briefcase he pulls some paperwork which he hands to you.";
    move the insurance paperwork to the player.

Example cited from Wikipedia

AppleScript is pretty close to that, though that is obviously platform dependent.

Here's a script for opening iTunes and playing a playlist

tell application "iTunes"
    activate
    play playlist "Party Shuffle"
end tell

Source: AppleScript Examples

This was "the next big thing" around about the early 1980s and I spent much of my first couple of years as a a coder working in "NATURAL", which was the supposedly the best of the new crop of 4GLs (fourth generation languages) which were designed to make data access (in this case to an ADABAS database) human readable.

Of course it did absolutely nothing of the type. All we ended up with was verbose badly structured code. Both of these products are still around, but you've never heard of them, which sort of proves the what a dead end it was.

Actually at that period there appeared to be a general desire to move beyond 'programming' into some sort of 2001 inspired AI heaven. Oracle were really keen on code generation and I remember with some interest a product called 'the last one' that was being marketed to managers as a product that would automatically generate any program you wanted and make all your programming staff redundant. Seems not to have lived up to expectations ;-)

It's worth remembering to that SQL was originally marketed in some quarters as a way to allow management to directly query their data. I was even sent on a course to learn basic SQL (in a large national transport organization that ran on rails - the steel variety) where junior management types were included because they had plans to put basic query tools in their hands. What a disaster that was.

Maybe it might be different in 50 years, but at the current stage of play coding demands a certain clarity of thought and implementation which is best mediated through a dedicated syntax designed for those ends, not any approximation to a natural language which is unclear and ambiguous. The nearest approximation is possibly physics where the essence of the subject is in the mathematics used (think a programming language for physics) not verbose wordage.

ADDED

I was forgetting, apart from COBOL there was also PL/1, sometime credited with allowing NASA to put a man on the moon it was just as verbose as COBOL and tried even harder to be 'Manager-readable'. Which is why no-one has really heard of it now either :-)

Projects promoting programming in "natural language" are intrinsically doomed to fail.

-- Edsger W.Dijkstra, How do we tell truths that might hurt?

All languages are 'human readable'. :) How else would someone be able to create it? That being said, languages that support DSLs can be incredibly intuitive such as Boo.

Chef! Anyone can read recipes right? Behold hello world!

Ingredients.
72 g haricot beans
101 eggs
108 g lard
111 cups oil
32 zucchinis
119 ml water
114 g red salmon
100 g dijon mustard
33 potatoes

Method.
Put potatoes into the mixing bowl. Put dijon mustard into the mixing bowl. 
Put lard into the mixing bowl. Put red salmon into the mixing bowl. Put oil into the mixing bowl. 
Put water into the mixing bowl. Put zucchinis into the mixing bowl. Put oil into the mixing bowl. 
Put lard into the mixing bowl. Put lard into the mixing bowl. Put eggs into the mixing bowl. 
Put haricot beans into the mixing bowl. Liquefy contents of the mixing bowl. 
Pour contents of the mixing bowl into the baking dish.

Sorry if it's not a serious answer, but this is way awesome. :-)

Having a programming language read like a (verbose) normal language, would be like requiring people to converse all the time in legalese. All the extra verbiage just gets in the way.

An ideal programming language should have syntax that is as transparent as possible and let the concepts behind the program stand out. Obviously there is a trade off between having a quick learning curve and having minimal but obscure syntax (think Perl, or even K).

By creating a set of rules, it is possible to do logic programming in Prolog like this. You can build a grammar (or download one) for a particular domain, create a knowledge base and then query it. After defining your grammar you could do something like:

bob is a parent of tim.
mary is a parent of bob.

?- X is a grandparent of tim.
X = mary

?- jim is a parent of bob.
false

I see the Shakespeare programming language have yet to be mentioned.

These programs are coded to look like shakespear plays, the individial characters in the play being variables that can hold numbers and the various phrases in the play manipulate the characters and the number they hold. For instance, "Speak your mind" orders a character to output his value.

Applescript:

tell application "Finder"
 set the percent_free to ¬
 (((the free space of the startup disk) / (the capacity of the startup disk)) * 100) div 1
end tell
if the percent_free is less than 10 then
 tell application (path to frontmost application as text)
 display dialog "The startup disk has only " & the percent_free & ¬
 " percent of its capacity available." & return & return & ¬
 "Should this script continue?" with icon 1
 end tell
end if

I can read C. That means it's human-readable(because I'm a human). It's just too terse for the average person. The general concept of programming languages is to maximize the information about how the computer should operate in a given line.

This is why Ruby is so popular; it maximizes the functionality in minimal text. English(or any other other natural language) is a pretty imprecise, low-information/character language.

In sum, it is: (i)done before and (ii)a known weaker idea.

This is actually a hot topic.

For starters - What is Human readable?

A Chinese-reader cannot read Russian and vice versa. It you narrow your domain for example to Chinese pharmacists writing a perscription you could design a language around that. And that would be human readable.

Such as language would fall under a the umbrella of Domain Specific Languages.

SQL

SELECT name, address FROM customers WHERE region = 'Europe'

Yes. It's called COBOL, and people generally detest it.

Inform 7 is the most successful such system I've seen. It has two advantages over the cruder systems listed in other answers here: it's for a domain particularly appropriate for natural language (interactive fiction), and it does a fancier analysis of the input code based on more computational-linguistics lore, not just a conventional programming-language grammar that happens to use English words instead of braces, etc.

HyperTalk and its descendant AppleScript were designed to be similar to the English language.

Perl, some people claim.

print "hello!" and open my $File, '<', $path or die "Couldn't open the file after saying hello!";

Do a google search for "natural language programming" and you'll find lots of information (including why this is a bad idea).

Clarity of Expression is important.

But Clarity of Thought is far, far more important.

VB is as close as I can think of one:

If MyLife.Sucks Then MyLife.End Else MyLife.Continue

Sure, Erlang.

-module(listsort).
-export([by_length/1]).

 by_length(Lists) ->
    F = fun(A,B) when is_list(A), is_list(B) ->
            length(A) < length(B)
        end,
    qsort(Lists, F).

 qsort([], _)-> [];
 qsort([Pivot|Rest], Smaller) ->
     qsort([ X || X <- Rest, Smaller(X,Pivot)], Smaller)
     ++ [Pivot] ++
     qsort([ Y ||Y <- Rest, not(Smaller(Y, Pivot))], Smaller).

I'm a human, it's a programming language, and I can read it. I don't know what any of it means, but I see a lot of English words in there, I think.

(Tongue firmly in cheek.)

DSLs can be very natural-looking. See this example created with MGrammar:

test "Searching google for watin"
    goto "http://www.google.se"
    type "watin" into "q"
    click "btnG"
    assert that text "WatiN Home" exists
    assert that element "res" exists
end

COBOL was intended to be read by managers, and has "noise words" to make it more readable.

The funny thing is, it reads a bit like a verbose DSL.

Being more human-readable than most was one of the early selling points of Ada. I find it a silly argument these days, as any sufficently complex task in any language is going to require a competent practicioner to understand. However, it does beat the bejeezus out of C-syntax languages. Its dominant coding styles can enhance this effect too. For example, comparing loops in an if statement: Ada:

if Time_To_Loop then
   for i in Some_Array loop
      Some_Array(i) := i;
   end loop;
end if;

C:

if (timeToLoop != 0) {
   for (int i=0;i<SOME_ARRAY_LENGTH;i++) {
      someArray[i] = i;
   }
}

The C code would look even worse if I used Hungarian notation like Microsoft, but I'm trying to be nice. :-)

I agree with the general consensus here. "Human readable" general purpose programming languages are mostly a bad idea, but human readable Domain Specific Languages are very worthwhile.

REBOL has a great system for creating DSLs.

Cobol was kind of like that.

IMHO, human readability is pretty subjective. However, if you want to learn more I would suggest exploring the following topics:

• Python - which uses prefers whitespace to 'special characters' (such as { & } for syntax).
• Smalltalk - which allows arguments to be spread through the method name.
• Ruby
• Fluent APIs / Domain specific languages

While not a programming language itself, the parsimonious XML shorthand language (PXSL) makes XSL a hell of a lot more human-readable (and less verbose!) than it arguably already is:

 <doc keywords="x y z">          doc -keywords=<<x y z>>
  <title/>                        title
  <body id="db13">                body -id=db13
    This is text.                   <<This is text.>>
  </body>
</doc>

I think the two constructs have very different purposes. Natural language has a very loose structure that is subject to interpretation and presumes the existence of a high-level inference engine to understand it -- and it is expected that it will be interpreted incorrectly a good portion of the time! Programming languages are meant to be precise, unambiguous specifications that leave little if anything open to interpretation.

Given that you'd think that using natural language as a programming construct should be a simple matter of taming its variability and clarifying its meaning. But once you've done that you're left with the semantics of a programming language, regardless of how it is syntactically wrapped and packaged.

That has to be whitespace. The only programming language where there's simply nothing to read: http://en.wikipedia.org/wiki/Whitespace_(programming_language)

Funny. Imagine an analphabet asking "Is there a human readable newspaper?".

Before you can read something you have to learn to read first.

Haven't seen ABC mentioned yet. Worked with that during first year computer science at Utrecht University and always thought that quite "human readable" (whatever that means exactly).

Here is an example function words to collect the set of all words in a document:

   HOW TO RETURN words document:
      PUT {} IN collection
      FOR line IN document:
         FOR word IN split line:
            IF word not.in collection:
               INSERT word IN collection
      RETURN collection

Visual Basic (and BASIC based languages in general) are about as close to human language as you get. I'd argue Python comes pretty close too. Using these you can makes your code read as structed english if you care enough, but no, there's no natural English compilers because there's just too much ambiguity there.

Basic was a first approach in that direction, and as has been shown in another reply, Perl also allows code that's fairly close to human language - if you ignore all that punctuation.

I just read a very interesting article on how to translate Latin to Perl (for which there's also a Perl module).

So if the human language has enough structure, and you introduce enough restrictions to avoid ambiguousness, you can indeed program in (mostly) human language.

But really nobody really does, because it's very verbose, and hard to make both readable and accurate.

Why would you do that? It's machine-unfriendly to our R2D2 in the brain, which reads the code to us.

In the early days Microsoft actually translated WordBasic (since many years known as Visual Basic for Applications) to match the GUI language. Constructs like

If <condition> Then
  <something>
End If

would, in the Dutch version of Word, be entered and displayed like

Als <condition> Dan
  <something>
Einde Als

Of course, in theory this made it easier for people to understand recorded macros. But I doubt those people would ever take a look at the code to start with...

There are lots of great DSLs (Domain Specific Languages) that read very much like human language.

A great example is Starbucks. You could write a DSL like this. This is using Ruby but could be done in many different languages. The advantages to Ruby or Python is that they are dynamic languages so you can use Duck Typing.

venti = Starbucks.new(:kind => :coffee, :size => :venti)
half_foam_venti = add_half_foam(venti)
serve(half_foam_venti)

But I have to agree that Ruby / Python might be the closest out of the box.

Kent

I says LOLcode for readablity:

HAI

I HAS A VAR ITZ "Hai der Werld", I HAS END

VISIBLE VAR

GIMMEH END

KTHXBYE

or

HAI

I HAS END

VISIBLE "Hai der Werld 2.0"

GIMMEH END

KTHXBYE

"w/o gimmeh the thing would only stay up for a split second" go to lolcode.com for moar info