Well here's a list of features I'd put in:

Lisp like syntax

Lisp style

Pros:

• Easily extendable syntax. Ever tried to implement a foreach loop in C? It's not exactly easy. (Mind you, I have done it).
• Homoiconicity. You can simply (eval "your data files")

Cons:

• Nested polish notation is often hard to read

Functional Programming

Haskell style

Pros:

• Easy concurrency, all code is thread safe.

Cons:

• Difficult to implement side effects in pure functional code, though monads seem to do a good job.

Strong dynamic typing

Python style

Pros:

• Dynamic typing makes clean readable code, Strong typing can eliminate type errors

Implementation:

Allow function overloading based on types, similar to CL's defgeneric:

(define (+ (a <int>) (b <int>)) (ints-add a b)) (define (+ (a <string>) (b <string>)) (string-concat a b)) (define (+ (a b)) (add-generic a b)) 

Compilable and Interpretable

Pros:

• Performance boost if compiled (usually true, not always)

Cons:

• Can limit features in the language, llvm would be a good backed though.

Systems programming

C style

Pros:

• Appeals to a, very slightly, wider range of users.
• Easier for applications, kernel and device drivers to interact if they're all written in the same language

Cons:

• Limits the abstractions in the language, dynamic typing is often not suitable.

Hygienic macros (CL style and Scheme style)

Pros:

• Easy to extend the language, especially with Lispy™ syntax
• I've said this before, haven't I?

Cons:

• Not many if done with Lispy™ syntax

Come to think of it, this more or less defines scheme, except for the compilation and systems programming bit. That can be worked around by using libguile and writing those bits in C.