Take the 2-minute tour ×
Programmers Stack Exchange is a question and answer site for professional programmers interested in conceptual questions about software development. It's 100% free, no registration required.

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.

share|improve this question
Scalability... And flexibility. –  Mark Canlas Feb 25 '11 at 19:32
To me, "smoothness" automatically contrasts to "crunchiness", which makes me think of peanut butter. –  FrustratedWithFormsDesigner Feb 25 '11 at 19:36
When compiling C# from the command line, you only need the .cs file. Why is it poor on the "one file" characteristic? –  configurator Feb 27 '11 at 5:39
@configurator Your point is entirely correct. I never use the command line to build when writing new C# code, nor do most people, but the feature exists. The scores I gave C#, Python and shell scritping are based on how I imagine people typically use those languages & environments. Anyone using different environments than I imagined will likely have different scores. –  Chris Apr 1 '11 at 18:42
Adoptability. The property of language to be happily accepted by team of more than 1 person per single continuous project. Measured in max achieved team size/headcount over lifecyle of project. –  user7071 Jun 4 '12 at 2:15
show 2 more comments

closed as primarily opinion-based by MichaelT, gnat, Bart van Ingen Schenau, GlenH7, Dan Pichelman Nov 19 '13 at 14:57

Many good questions generate some degree of opinion based on expert experience, but answers to this question will tend to be almost entirely based on opinions, rather than facts, references, or specific expertise.If this question can be reworded to fit the rules in the help center, please edit the question.

5 Answers

up vote 2 down vote accepted


The degree to which a system's components may be separated and recombined1

Describes both the ability to look at the small picture without worrying about everything else, as well as the ability to put many small pictures together into a bigger one.

share|improve this answer
add comment

Although all three of your examples make it somewhat difficult, you have to separate the language and the running environment.

What you described is the scalability of the language itself, how well it scales to large/small problems.

Which shouldn't be confused with runtime scalability, which isn't a property of the language at all.

Update: After the clarification I think versatility better describes what you're after.

share|improve this answer
My question is about the challenge of using languages, not just writing code. Compilers, shells, interpreters, IDEs, and the like all contribute to usability just as languages themselves do. Edited the question to clarify. –  Chris Feb 25 '11 at 21:03
@Chris Stevens I see. Updated my answer then. –  biziclop Feb 25 '11 at 22:58
add comment

"Usability" or "adaptiveness".

I don't think there's a single word to describe the (wide) range of concepts you're trying to convey.

share|improve this answer
add comment

Well, "smoothness" seems hokey and doesn't express anything.

I don't think "granularity" does it either and besides, it's already used in design talk to refer to where to separate modules.

share|improve this answer
add comment

Scala was designed, and named, specifically for this quality. They call it "scalability" in that programs in Scala should be able to easily scale from small to large, but that word is kind of overloaded these days.

share|improve this answer
add comment

Not the answer you're looking for? Browse other questions tagged or ask your own question.