Language creation

I recently started thinking about creating a programming language from scratch, but obviously heavily inspired by existing programming languages out there.

I don’t have anything concrete yet but these are the main principles I came up with for the language:

• Somewhat functional (but not purely functional). So side-effects should be more or less easily possible within non side-effecting code. Mainly for reasons regarding the process of actually building the compiler / interpreter and that it should be a dynamic language. Especially the last point makes it pretty obvious that since there is no static typechecking, making  it purely functional would be kind of hard to realise (although possible i guess). 
• Garbage-collected / automatic memory management. Kind of makes sense with a functional language and who really wants another assembly-like, low-level language?
• An easy way to extend the language in itself (as in Lisp, for example, with macros or some similar meta-programming capability).
• Dynamically typed (like Lisp or Ruby for example)
• Small, in the sense that the language itself should not be bloated and most of the value of it shouldn’t be part of the language itself, but implemented in it. By that I don’t only mean the standard library, where this usually is the case already, but also those things, often considered part of the language (or “built-in”) in other languages. Haskell is a good example of operators and data types not being tied completely into the language, but rather implemented in it. A good example is the Boolean data type, which is merely defined in Haskell itself (and if it hadn’t been, it would be trivial to come up with your own). This works because Haskell uses some very nice pattern matching with its algebraic datatypes and I could imagine something similar for my language.

That are my main concerns this far. Obviously theres still much to decide, mainly syntax and semantics. Compelling are Haskell’s typesystem with its really powerful, yet simple datatypes and pattern matching. On the other hand there’s Lisp with its macros and Ruby with its also powerful meta-programming mechanisms.

Let’s see, where this will go