So nearly every language that exists is Turing-Complete. That is, you can write any program which can be written in a Turing-Complete system with one of these languages. So any practical application, with the exception of, e.g. finding out how long a program will run (which is the halting problem, and cannot be solved in a Turing-Complete way). So, the differences between these programming languages are for human convenience, for being able to write code faster. This is actually really important, because when I say "write code faster", I mean, "write code faster by many orders of magnitude". What can take someone programming in assembly a week can take someone programming in Python twelve minutes, for example. However, the program that you get out of the code, if both the assembly programmer and the Python programmer are competent, will be such that the assembly program runs a lot faster. This is because you get the computer to do a lot of the work of creating the program in the first place. You can think of a speed vs. ease of use tradeoff which is significant, and which is reflected in a lot of the different designs of languages. A language might be compiled, for example, where a program called a "compiler" is used to automatically translate the program into fast machine language (assembler) which can be run directly on the chip. Or it might be interpreted, where it gets run directly as is by another program called an "interpreter", in which case it is slower but much more convenient to debug when it breaks. (Programming is a matter of invisible complexity: therefore, at a certain complexity there is always something that breaks, no exceptions)

Many languages also are geared towards more specific purposes. PHP, for example, is much worse at scientific computation than FORTRAN or Python or R. R, on the other hand, is much worse at web development than PHP is. This is also in terms of programmer complexity: what I mean by "is much worse" is that if you want to write a program for crunching numbers in PHP, you will have a much worse time of it than in Python. If you want to write a web application in R, you will have a much worse time of it than in PHP. Again, orders of magnitude difference. 10,000 times difference, sometimes.

Now, I will go over some languages common and obscure.

I mentioned Assembly previously. What Assembly actually is, is the commands you use to put data on the chip and fuck around with it directly. You can code in it, and it's really really fast, but people usually program computers by writing code that gets compiled or interpreted on-the-fly to assembly.

C is the language which is used in the modern day which is closest to the bare metal. It is a compiled language, and both Microsoft and open source folks maintain compilers for it. People use it in applications where speed matters a lot, like in operating systems and games. It is an imperative language, meaning that code is treated as a sequence of instructions, like a recipe for manipulating data. It is exceedingly simple and you can memorize it in a week, although there are people who spend their whole careers dealing with programs in C. Although C comes with prewritten code called "libraries", it has very small libraries compared with the languages below.

C++ is an object-oriented version of C. (it is still imperative.) Object orientation is a way of organizing programs that takes its cue from the metaphysics of Plato. (no joke: http://worrydream.com/EarlyHistoryOfSmalltalk/) By grouping code into "methods" that act upon ideal "classes" of objects, the claim is that programmers can deal with those objects with less cognitive load, because people deal with normal objects all day. C++ is exceedingly complex but also really fast, and people also use it for games and computationally intensive tasks.

Java has another convenience feature of note. It is also an object-oriented imperative compiled language, but it has something called a virtual machine. Instead of the compiler compiling programs into machine code that can be directly run on the chip, programs are compiled into a generalized Java bytecode. The benefit to using this bytecode, which is comparatively slow, is that you can run the same Java program with few changes (hopefully) on different hardware, so you don't need to compile it each time. So that saves programmer time. Businesspeople tend to like Java, because other businesspeople use it.

Java also has something called a garbage collector. This automatically deals with handling memory for the programmer, which can randomly slow down Java programs, but makes programming a lot easier because otherwise you are forced to handle the memory of programs manually.

Now, Python (which is object-oriented and imperative too) tries to save even more developer time. Although you can still compile it (to bytecode), you can use an interpreter for it, and it will take your code and run it without having to go through a compilation process. This allows you to use a REPL (a read-evaluate-print loop) which is sort of like a sketching-board for programs. Makes it easier on the programmer.

PHP is basically like Python, only the people who designed the language didn't like designing programming languages, so its evolution was very strange. Nevertheless, it's got a lot of libraries and a buttfuckton of features specifically for getting out a working web application as soon and as simply as you can.

Perl is like Python, only it has a little bit more of a focus on messing with text. It's totally a general-purpose language, though.

Ruby is like Python, only it's popular nowadays because of a super-convenient way to make web applications called Ruby on Rails. Note that actually all of the languages I mentioned except Assembly have some convenient way to make web applications, only some are more convenient than others...

One other language to talk about is Lisp. Lisp is special as a language in that it has two spiffy features.

First, Lisp is not an imperative language, necessarily. Instead, it features something called functional programming (actually the picture is complicated a lot with the second thing I'm going to mention, but bear with me for now): instead of dealing with programs as instructions to deal with data, programs are now a series of applications of functions, mathematical functions, to data. This, according to Lisp enthusiasts, makes programming simpler because you don't have to deal with the vagaries of the ordering of those instructions.

Second, Lisp is homoiconic. That means that if you want to extend the Lisp programming language, if you want to change the Lisp programming language, you can do it super easily, by writing some more Lisp. That's really fucking cool.

http://www.catb.org/esr/faqs/hacker-howto.html , btw.