Here is what I think makes a good programming language:

1. Has a well-defined semantics that makes it easy to reason about what your program will do.
2. Has nice library support for data structures, interfacing with the operating system, etc. (C++ STL, OCaml's batteries).
3. Programs written in the language are easy to read.
4. Allows you to write at least some things that have good performance. (Domain-specific is okay.)
5. Has more than one person maintaining it.
   

Here is why programming languages get adopted:

1. Accident/legacy reasons.
2. Yields good performance on a small set of operations (Fortran, Matlab).
   
3. Has a good set of libraries.
4. Named in a way that causes people to confuse it with another programming language. ::cough:: Javascript.
5. People learn it in school.

I agree with Jean Yang, but I want to add a few bits which are important to me:

• Good documentation: Every function should be well-defined, but also have some examples how to use it and hints about potential problems. The documentation should be online, hosted at an "official" source and directly linking to functions / methods / objects / classes / ... should be possible.
  
  Good examples are:
  - PHP with PHP Manual - Manual
  - Python with 2. Built-in Functions
  - Ruby with Index of Files, Classes & Methods in Ruby 2.1.5 (Ruby 2.1.5)
  - TCL with Tcl Commands
  
  OK examples are:
  - Java with Java Platform SE 7
  
  Bad examples are:
  - JavaScript (ECMA): There is JavaScript, but it is not official
  - C++
• Community: This one is hard or even impossible to measure. From personal experience, I would say that Python, PHP, C++, Java, JavaScript have a good community (on Stack Overflow), but TCL, X10 and Prolog don't have that.
• Package distribution: Python has the possibility that users package their libraries (modules) to packages and distribute them via PyPI - the Python Package Index / pip (a command line tool). I think ruby has the same with gems and Java also has something similar (how was that called?). I think for Perl it is CPAN.
  
  There are certainly differences in quality of the package distribution.
• Good, common solutions for common problems: Some problems are very common, like generating a documentation for your code, writing tests, parsing command line parameters. Every language should have a standard way to do so which leads to reasonable results.
• Conventions: Naming schemes as well as other conventions lead to code which looks familiar and thus makes it easier to read other peoples code.

All current answers lack a very important aspect:

The best way to do anything should always be the laziest way

Take Kotlin for an example: every class is final until declared open. Making an immutable variable is no additional work compared to making a mutable one (var vs val)

Compare that to Java, where ideally you'd have everything be final unless required otherwise. Or C++ where you'd want to have everything const unless explicitly required otherwise.

Another example is Rust: immutable values (C++ const) are “let x” compared to “let mut x”. C++ RAII and move semantics are the language’s default way of handling resources properly.

Remember that 50% of programmers will always be junior developers (according to Uncle Bob Martin) and therefore prefer to use the laziest way without thinking. So making the best way the laziest automatically improves overall code written in that language.

Otherwise the most three important aspects for me are

1. An extensive and well-maintained standard library (Scala and C#, …)
2. Easy construction and destructuring of tuples and record data structures (Python, Scala, C#7, Rust, …)
3. First class collection support

A good standard library massively reduces the need for external dependencies, which in turn reduces learning time for a new project for new developers which already have experience with the language.

Handling data in a concise way is important. And returning two values if often a necessity. So nothing is worse than having to create an entirely new class with fields, getters and maybe setters, equals and hashcode implementations for returning two values (thanks Java). C#, C and C++ work around this by enabling you to pass a reference or pointer to a local variable to a function which then sets this variable. But output parameters are confusing as we expect parameters to be a function’s input. But even in languages with nice struct syntax (C#6), binding the return values to different variables takes boilerplate code. Wouldn't you much rather have something like

def pointTimesTen(x: Int, y: Int) = (x * 10, y * 10) 
val (x, y) = pointTimesTen(7, 13) 

Many languages additionally provide shorthand for structures like case classes (Scala) or data classes (Kotlin). But that's another topic.

Another important aspect is first class collection support. In many earlier languages, collections are hard to use. Take C arrays for example, where you have to pass the length around as well. Or Java ArrayLists, which had no useful literal notation until Java 10 and required a for-loop for everything remotely useful. Compare that to languages like Rust, Dart and Scala (example):

val myList = List(1, 2, 3) 
val timesTwo = myList.map(_ * 2).toSeq 
val mySet = myList.toSet 
val oddNumbers = myList.filter(_ % 2 == 1) 
(myList ++ timesTwo ++ oddNumbers).forEach(println) 
 
val myMap = Map('a' -> 1, 'b' -> 2) 
val one = myMap('a') 
val doubled = myMap.mapValues(_ * 2) 

Collections are always important, whatever you do, and using them concisely and expressively is probably the most important thing for a modern programming language.

So, that's it. This answer is far as complete, but then again the other answers already cover a broad range of topics. So I suggest you read them as well. Cheerio!

Good languages are very formally designed, not just context-free syntax in EBNF, but formal semantics defined independent of any machine constraints (as will be reflected in operational and translational semantics), but defined in denotational and axiomatic semantics.

While it might sound that such complex language theory will end up with very esoteric and hard-to-understand languages, it is the reverse. These techniques will help design clean and clear languages that do what you expect — languages free of cruft and nasty surprises.

Language design needs to be tasteful — it is what is NOT in a language, not what is included. Too many industrial languages have been designed by people who want this or that, or accepted non-essentials as being fundamental. We end up with messes such as C++, just trying to compete by including all features of all other languages. The followers (cultists) of such languages make poor excuses such as “that is what is needed for ‘real world’ programming”. That just shows a complete non-understanding of the simplicity, yet power of programming.

For instance many think that pointers as in C are a fundamental. They are only an implementation mechanism and should be hidden behind a language. That is a language handles the details of locations (l-values) and programmers don’t need to handle those details. But worse, when programmers can manipulate addresses, setting something that referred to this, refer to that, it undermines the high-level reasoning about program correctness, but the low-level security of a system undermining the execution mechanism. Hackers love that — but languages and the platforms they run on must be secure. Languages that include C-style pointers are not just tasteless, but dangerous.

The best languages are designed by people who have deeply studied language design. John Backus was one of the originals in FORTRAN and ALGOL, the Niklaus Wirth (from Pascal to Oberon), and Bertrand Meyer who wrote the book ‘Introduction to the Theory of Programming Languages’ and also some books referenced below.

Unfortunately, being a language designer gives widespread recognition and fame, and people have been attracted to this and designed many languages without good knowledge. But when someone has little, they are more vocal about their ‘achievements’ and these languages have formed cults around them, despite their egregious flaws that place burden on the programmer that should not be there.

Here are a couple of languages which are well designed and should be the paradigms of modern languages.

The two paradigms of OO, but opposite poles are Smalltalk and Eiffel. Smalltalk is the ultimate in dynamic languages leaving checking to run time, Eiffel the ultimate in static compile-time checking. But they both do this very well. Most other languages – particularly ‘industry standard’ are in between and do fairly poor implementations of OO. Such languages obfuscate OO rather than present it cleanly.

Eiffel at Codeboard Tutorial

Touch of Class (Eiffel)

This is a book for beginning university students that explains much of the details behind computing. It goes all the way from basics to advanced topics such as lambda calculus and complex, large-scale software development (software engineering).

Object-oriented Software Construction (Eiffel)

For a more detailed look at software development for professionals, but at least first section will explain what we should be trying to do (which is programming, not coding). This is a classic on programming and OO.

Object-oriented Concepts

Free Smalltalk Books

Pharo (Smalltalk)

Squeak (Smalltalk)

Squeak/Smalltalk

Cincom (Smalltalk)

What Smalltalk Does?

Which "good" are we talking about? :)

• Mechanical Transparency? A language should have semantics that expose the underlying structure of the machinery. Ideally, this means that you have the option to do manual memory management and play with pointers. Example: C.
• Safety? On the other hand, we don't want to leave loaded guns lying around the kindergarten, so the semantics of a language should also enable varying degrees of control over the risk-versus-control trade-off that programmers should be allowed to take. Example: Hack, Erlang.
• Expressiveness? Various people and cultures tend to think about the world in different ways. If a computer language has semantics that more closely reflect the landscape of a particular domain, it takes less effort ("there are fewer transformations") for someone in that domain to get things done with that language. Often, computer programmers will want computer languages to reflect natural language. Example: domain-specific languages, scripting languages like JavaScript, PHP, Python, Ruby.
• Mathematical Elegance? It would be nice to have electronics that reasoned about the world in an elegant mathematical fashion, someday (if it's even possible without mechanical memory management). However, at this point in history, electronics and mathematics work rather differently - which is why the first point above is important. However, as humans within a tradition of mathematical thought, we would like to use abstract ideas such as functions, sets, and recursion to think about our programs. Some languages have clear and simple representations of such abstract ideas. Example: Lisp, Haskell.
• Cross-platform Compilation? ("cross-compilability") A text, in the literary sense, is just a bunch of marks on paper. Computer languages are no different. They only "mean something," within the context of a transformation. Compilers transform source code that is written by humans, into other forms that different run-time systems can understand, step-by-step, until they reach an underlying physical processor. Some apps can run on Windows, and not on OS-X, on the same laptop - specifically because there are different pieces of (software) machinery in between the source code and the underlying electronics. In such an environment, is (socially/operationally) beneficial for a language to have enough accompanying compilers, interpreters, or build-chains in its eco-system to enable the initial source code to be transformed into various forms that are usable on different underlying software/hardware environments. Example: JVM, LLVM.

Just some initial thoughts. There are many good points in other answers, that I'll try to avoid repeating.

Having worked with many languages, I would say:

A good programming language is the one that makes it easier for you to do your job and you feel confortable with.

So, I’ll expand a little. While all of the answers are really good and make sense, it’s not ONLY about the language, but the user. Why is it, that being Java and C# almost identical, some people prefer Java while others go for C#?

The answer is, because of the need. The language is good for WHAT?

C++ is a terrible choice for interactive web site. Because it’s useless, since browsers don’t undestand C++. Browsers understand HTML, CSS and JavaScript.

But C++ is great for operating systems, device drivers and game development (among other things)

So, I stand with my answer.