The Paradox of Programming Languages
I find it interesting that languages designed for non-programmers always result in and epic fail. The two most well know examples are COBOL and Visual Basic. While the languages themselves took off, you rarely hear anything good said about either.
You would think that languages for non-programmers would be wild successes since there are so many more non-programmers than programmers. Instead, they create a new breed of programmer.
OTOH, Languages designed for programmers and engineers tend to do well. Though there are epic battles (Ruby vs Java for example), they are taken seriously. Even when they don't succeed (aka gain major mind share) they still receive serious consideration.
Why Do Languages for Non-Programmers Fail?
Language for non-programmers fail because, they miss the point. The hard part of programming is NOT the language. The hard part of programming is solving problems. The programming language is just the tool we use to express the solution. Anybody can learn just about anybody programming language. Not everybody can use it to solve problems.
This is something that designers of DSLs need to take to heart.
Soon, programmers must be hired to fix/implement things in these languages. Businesses have been sold on how easy these languages are, so they are reluctant to pay a competitive developer salary (in the beginning). The result, most developers tend to be entry level they write code that entry level programmers write.
The Road Downhill
So, combine a language touted as easy, with lots of bad code, and soon everyone thinks the language is evil. Businesses need experienced people to maintain old code, many professionals shun the languages, things rot.
Be careful about how the word easy gets brandied about. Business types don't see why they should pay a high salary to do something that's easy.
Languages written for non-programmers tend to get in the way of programmers. Often, it's little things meant to protect the non-programmers.
Many enter into the idea of writing DSLs so that business people can affect the logic of an application. Many are realizing the fallacy of this already. Personally, I prefer Martin Fowler's idea of creating business readable languages instead.
Love the Language You Have
I think the ultimate goal should be to create a language for engineers and programmers that gives them the power to do what they need while being readable enough that non-programmers can look at pieces of the code and get an idea of what's going on.
Of course, we don't really need a new language to do that. With good variable and function names, and proper layering of abstractions, most non-devs can get an idea of what's going on, regardless of your programming language. So, can your fellow developers by the way.
Before someone says I'm advocating only using one language, let me state right off: if you are a developer, you should be choosing the best one for the problem at hand. If you are not a developer, then let your developers decide the best language to use for the problem/project. That is part of what you pay them to do.