Axe
Like:
    Fast and portable.
Dislike:
    Not as much control. (Can't wait for Axsembly!)

C/C++
Like:
    Low-level.
Dislike:
    Inconsistent syntax.

Java
Like:
    Strict syntax. (Some people love it, most people hate it.)
Dislike:
    Strict syntax. (Ditto.)

Javascript
Like:
    Intuitive once you get the hang of it.
Dislike:
    Syntax too wordy without jQuery.

jQuery
Like:
    Compatible, consistent, and elegant.
Dislike:
    Slow.

Lua
Like:
    Cross-platform, fast.
Dislike:
    Tables. (I'm still stuck in the OOP paradigm.)

PHP
Like:
    Widely accepted web programming.
Dislike:
    Very slow, inconsistent, and too trapped by its own backwards-compatibility (the same problem as C++).

Python
Like:
    Extremely intuitive and elegant.
Dislike:
    Slow.

TI-BASIC
Like:
    Portable.
Dislike:
    Slow, highly constricted (on Nspires).

Windows batch
Like:
    Convenient.
Dislike:
    Structure and syntax quirks. (What? They actually force me to use GOTO?)

Z80 assembly
Like:
    Low-level.
Dislike:
    Too repetitive in some ways.

Okay, thanks. Now, let's say speed is irrelevant. I'm talking more about language features.
For example:
Java:
 like:
  garbage collector
 dislike:
  almost no control over the garbage collector
  the internal workings of Java itself allocate memory, (seriously. I have a program where ALL the memory is allocated at the start. All other allocations were from Java class library calls.)

SuperH Assembly:

Likes:
Instructions are a constant two bytes large.
Most normal operations have dedicated opcodes.
Single cycle execution time for all by a handful of instructions.
Simple syntax.
Highly backwards compatible.
Powerful.

Dislikes:
Certain important operations, such as MOV.L @Rm-,Rn aren't supported.
It takes a lot of code to do non-trivial things.
The division opcodes are extremely difficult to use efficiently.
Too few registers.

x86/x64:

Likes:
Powerful.
Hardware support for pretty much every function you could reasonably desire.
Large number of available registers.

Dislikes:
Slow execution of many instructions.
Inconsistent and highly variable instruction size.
Branch execution is very difficult to optimize.
The "standard" x86/x64 instruction set is badly defined and many different variants are floating around.

Axe:

Likes:
Fast.
Fairly powerful.
Makes greyscale simple.

Dislikes:
Often not as efficient as pure z80.
The syntax is too strict.

Java bytecode:

Likes:
Powerful.
It's an elegant language.

Dislikes:
Some of the instructions are annoyingly complex and the garbage collection means that you have to be careful with your pointers.
Slow (unless interpreted by hardware).

CIL bytecode (.net):

Likes:
It's limited Turing complete.

Dislikes:
Slow, complex, and garbage collection.

Axe
Likes: It actually has a pretty loose syntax, and is pretty powerful and extremely easy to code in.
Dislikes: Its variable system can be limited at times and makes you have to use pure pointers very often, and the principle of least surprise isn't seen at all: code written by a newbie can be hard to understand sometimes -- unless you wrote the code, good luck trying to decipher it.

z80 assembly
Likes: fast, and with a good assembler like Brass or SPASM you can get away with murder in many cases.
Dislikes: extremely strict syntax for many instructions, and many instructions you would think would be supported, aren't in most cases.

C
Likes: very fast, and like Axe can have a nice, loose syntax.
Dislikes: strict procedural rules and like Axe, the Least Surprise ideals are missing -- if you skip over one line of code, you might not understand the entire thing.

C++
Likes: adds OOP to C
Dislikes: a horrible implementation of OOP.

Python
Likes: very intuitive, and actually pretty fast for an interpreted language.
Dislikes: not as flexible with lambda statements and block coding.

Ruby
Likes: Beautiful syntax that builds upon python's, very easy to read and code can be extremely loose and condensed at the same time.  Plus, great handling of lambda statements and blocks.
Dislikes: lower-level things can be very slow, but it beats python for speed if you use the YARV or JRuby frameworks.

Ada
Likes: a C-like language with much more flexibility and better syntax
Dislikes: not as many people besides the government use it, so it's hard to find as many modules/libraries for it.

Java
Likes: a decent approach to OOP, definately beats C++'s by a long shot, and many more OOP features than many other languages
Dislikes: horrible syntax, too high level and low level at the same time, since it supports primitives AND high level objects, which can lead to stupid code

Groovy
Likes: Java done right.
Dislikes:  not many.  Maybe just things not having to do with actual code, like the pain you go through just to set up a project correctly and make it work with Java resources.

D
Likes: a bit of an improvement on C++, with more flexibility with objects and polymorphic code
Dislikes: still has horrible OOP like C++

Javascript
Likes: I really don't like anything about it
Dislikes: where to start?  Horrible syntax, horrible fake OOP is fake and horrible, pretty slow, and most applications require a lot more code than other scripting languages

Lua
Likes: it's form of 'OOP' (I use that loosely) -- it's extremely flexible and fun to write in, and is pretty decently fast
Dislikes: not that much module support, and the standard debugger really sucks at supplying feedback

Ok, I still would like more people to comment please...

Okay, I'm reviving this topic, and changing it a little. What features would your perfect programming language have?

Why no objects?