The simplicity of a programming language also strongly affects the readability of the programs. And also, programs that are easier to read and understand are easier to maintain. Developing and implementing a compiler or an interpreter for a simple programming language is also easy.

However, designers should not sacrifice the power needed for the language to achieve simplicity.

2. Naturalness: A good language for an application area should be natural for programming applications. It should provide appropriate operators, data structures, control structures, and a natural syntax to facilitate programmers to code their problems quickly and efficiently.

FORTRAN and COBOL are good examples of languages possessing a high degree of naturalness in scientific and business application areas, respectively.

3. Abstraction: Abstraction means the ability to define and then use complicated structures or operations in ways that allow programmers to ignore many of the details. The degree of abstraction a programming language allows directly affects its ease of programming.

For example, object-oriented languages support a high degree of abstraction. Hence, writing programs in object-oriented programming (OOP) languages is much easier. Object-oriented languages also support the reusability of program segments due to this feature.

4. Efficiency: A program written in a suitable programming language enables a computer system to translate it into machine code efficiently, execute it efficiently, and manage it with less memory. A good programming language is supported by a good language translator (a compiler or an interpreter) that considers space and time efficiency.

5. Structured programming Support: A good programming language should have the necessary features to allow programmers to write their programs based on structured programming concepts. It significantly affects the ease with which a programmer can write, test, and maintain their programs.

Moreover, it forces the programmer to look at a problem logically so that they create fewer errors while writing a program for the problem.

6. Compactness: In a good programming language, programmers should be able to express the intended operations concisely without losing readability. Programmers generally dislike verbose language because they need to write too much. Many programmers dislike COBOL because it is lengthy (lacks compactness).

7. Locality: A good programming language should be such that while writing a program, a programmer need not jump around visually as they prepare the program’s text. It allows the programmer to concentrate almost solely on the part of the program around the statement they are currently working on.

COBOL and, to some extent, C and Pascal lack locality because data definitions are separated from processing statements, perhaps by many pages of code, or have to appear before any processing statement in the function/procedure.

8. Extensibility: A good programming language should allow extension through simple, natural, and elegant mechanisms. Almost all languages provide subprogram definition mechanisms for this purpose, but some are weak.

9. Suitability to its environment: In addition to being suitable for its application area, a good programming language must also be ideal for its operating environment.

For example, a language for real-time applications must be interactive. On the other hand, a language for data processing applications like payroll, stores accounting, etc., may operate in batch mode.

1. Nature of the application: A programmer should select a language appropriate for the application area.

For example, FORTRAN is convenient for scientific and engineering applications, while COBOL is suitable for business applications.

2. Familiarity with the language: If the programmer finds multiple languages suitable for the application area, they should select the one with which they and other programmers in their team (who will code the application) are most familiar.

3. Ease of learning the language: If the programmer finds that multiple languages are suitable for the application area and the programmers are not familiar with any of them, they should select the language that is easy to learn and use.

4. Availability of program development tools: Before selecting a language, the programmer must also find out if the programming environment of the language has good program development tools like a compiler, interpreter, debugger, linker, etc.

A language with a good set of program development tools can drastically reduce the time and effort of the team of programmers involved in coding an application.

5. Execution efficiency: If the execution efficiency of an application is essential, the programmers can use an assembly language instead of a high-level language for coding the application. Because an assembly language program written by a clever programmer usually has a shorter production run time and takes less storage space than a program written for the same application in a high-level language.

6. Features of a suitable programming language: Finally, the features of a good programming language discussed in the previous section often influence the selection process.