Wiki, and TheLiterature (and all manner of casual programming conversation) is chock full of claims like "Language X is simpler (more complex) than language Y, because..."  Many such claims are based on rather trivial metrics, like number of keywords, etc.

What is a ''meaningful'' definition of simplicity/complexity?

* Ease with which a novice can write his own HelloWorld program?
* Ease with which a novice can become a competent programmer in the language?
* Ease with which a novice can become an expert in the language?
* Ease of implementation of the language?
* Ease of extension/tool development?
* Ease of developing simple applications (glue code, CrudScreen''''''s)
* (Relative) Ease of developing difficult applications
* Ease of developing applications in the language's intended domain area?
* Ease of developing applications outside the language's intended domain area?

And various metrics which get bandied about

* Size/complexity of grammar (number of rules of BNF, presence of ambiguities, etc.)
* Number of keywords or "special forms"
* Size of the standard library
* Comprehensiveness of standard library
* Number of "kludges" in the language definition (all mature languages have quite a few, it seems)
* Presence of any smaller "subsets" of the language which are useful (does the EightyTwentyRule apply to the language)?
* Number of ForDummies books, training courses, college courses, etc. available for the language
* Quality of implementations/tools/environments
* Way programs are entered, integration with environment
** ImageBasedLanguage (ie SmalltalkLanguage)?
** EditCompileLinkRun language (ie CeeLanguage/CeePlusPlus)
** VisualLanguage (dragging controls onto forms, etc.--i.e. VisualBasic)
** ScriptingLanguage (edit and run, no explicit compile/link steps necessary)
** ReadEvalPrintLoop (various flavors of LispLanguage)


There isn't (despite what some will tell you) a clear cut answer to the above; and many of the above factors are opposing.  (I.e is it better to have a "simple" language like AlgolSixty, SchemeLanguage, or PascalLanguage with a minimalistic library; or something like JavaLanguage or DotNet with libraries for everything under the sun?  When measuring complexity, should libraries be considered separate from the language or extensions of the language (such that you measure core language + libraries)?)


----
CategoryProgrammingLanguage CategoryComparisons CategoryComplexity