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.
