So I've been doing some reading about different kinds of programming languages and found some really good references, and it feels like my head is going to explode some of the time. I think that there's going to be a bit of a tradeoff on how powerful a language is versus how readable and maintainable it is. It's nice to be able to get a lot done in a few lines of code, but if those lines of code make no sense to anyone but the writer, it just doesn't do much good. It's obvious to me that comprehension of code drops dramatically when a single function won't fit on the page at one time.
I think strong typing is a good thing. The ability to detect type mismatch at compile time (or in the IDE) as opposed to at runtime is a really good thing. I think that errors at runtime should be minimized where possible. However, I also think that implicit casting is also a good thing. I don't want to have to tell the damn machine that yes, I know this is an integer and yes, I want to use it as a float. It should just work, and if the cast is legit, it should do it with no warnings at all. Some type casting makes no sense, however, and that's when it should throw errors, or at least warnings for cases where it could be a problem but night not be.
Do I want to allow operator overloading? Really, that's just another form of function overloading, just allowing extending the definition of tokens with a normally fixed meaning at parse time. I don't want to have a language that allows redefinition of reserved words. That's just too painful for me. Sure, it's powerful, but that goes back to power versus readability. (Note that's not the same as allowing variable names to be the same as reserved words - that might be allowable due to a difference in scope, but it could make the parser too complicated.)