One of the best things about programming is the abundance of different languages. There are general purpose languages like C++ and Java, as well as little languages like XSLT and AWK.

When comparing languages, people often use things like speed, power, expressiveness, and portability as the important distinguishing features. There is one characteristic of languages I consider to be important that, so far, I haven't heard [or been able to come up with] a good term for: how well a language scales from writing tiny programs to writing huge programs.

Some languages make it easy and painless to write programs that only require a few lines of code, e.g. task automation. But those languages often don't have enough power to solve large problems, e.g. GUI programming. Conversely, languages that are powerful enough for big problems often require far too much overhead for small problems.

This characteristic is important because problems that look small at first frequently grow in scope in unexpected ways. If a programmer chooses a language appropriate only for small tasks, scope changes can require rewriting code from scratch in a new language. And if the programmer chooses a language with lots of overhead and friction to solve a problem that stays small, it will be harder for other people to use and understand than necessary. Rewriting code that works fine is the single most wasteful thing a programmer can do with their time, but using a bazooka to kill a mosquito instead of a flyswatter isn't good either.

Here are some of the ways this characteristic presents itself.

• Can be used interactively - there is some environment where programmers can enter commands one by one
• Requires no more than one file - neither project files nor makefiles are required for running in batch mode
• Can easily split code across multiple files - files can refeence each other, or there is some support for modules
• Has good support for data structures - supports structures like arrays, lists, and especially classes
• Supports a wide variety of features - features like networking, serialization, XML, and database connectivity are supported by standard libraries

Here's my take on how C#, Python, and shell scripting measure up. Python scores highest.

Feature           C#          Python      shell scripting
---------------   ---------   ---------   ---------------
Interactive       poor        strong      strong
One file          poor        strong      strong
Multiple files    strong      strong      moderate
Data structures   strong      strong      poor
Features          strong      strong      strong

Is there a term that captures this idea? If not, what term should I use? Here are some candidates.

• Scalability - already used to decribe language performance, so it's not a good idea to overload it in the context of language syntax

• Granularity - expresses the idea of being good just for big tasks versus being good for big and small tasks, but doesn't express anything about data structures

• Smoothness - expresses the idea of low friction, but doesn't express anything about strength of data structures or features

Note: Some of these properties are more correctly described as belonging to a compiler or IDE than the language itself. Please consider these tools collectively as the language environment. My question is about how easy or difficult languages are to use, which depends on the environment as well as the language.