Paul Graham wrote an article about judging a programming language by its cover, explaining the use of hacker radar to infer knowledge about a language that you never wrote a code in it. I won't comment on his reasoning however while traveling through the land of programming languages I've found another quick method that will tell you a lot about the language without the need to write any code in it. Its called judging the language by its implementation.
First type of languages lack a functional implementation. There's web site saying how this language will be solving whatever is bothering the language designer and you might find paper(s) describing the language. These aren't languages at all, move over there's nothing to see. Unless you are interested in vaporware.
The second type are those with interpreter written in some other high level language that looks like it was bolted together over the weekend by some student hastily preparing the seminal assignment. Just skip those too, if you found the concept really appealing bookmark the site and visit it after few months to see if there is any progress.
The third type is minimalistic interpreter but this time the interpreter feels good, supporting several operating systems and on each it just works without tweaking. Usually this type of languages started their life as a research toys or maybe a scripting tools that proved itself useful thus gaining life of their own. Though minimalistic this languages might be battle proven in production environments for many times. If the field this type of language targets interests you, you might be well served. I believe in this case existence of viable community should be deciding factor. If there are at least 100 active users, go for it as people that gather around this niche languages tend to be very knowledgeable and helpful.
The fourth type are languages that I call pioneering languages. You could recognize them claiming tools that exist only for the mainstream languages, like integrated development environments, code browsers etc but instead of providing their own they piggy back as plug ins on mainstream languages tools. This should be warning sign, if the plug ins work without tinkering the language might be usable, else you are in the land of pioneers and pioneers are the ones with arrows in their backs. Proceed at your own risk.
The fifth types are the ones with development environments of their own but you need to install like gazillion dependencies, many of those are external (usually dated) versions of popular run-times like .NET or JVM or many popular libraries. Avoid this like a plague. This a sign of language that was once popular but has fallen from grace and now instead of choosing its niche is over reaching trying to everything to everybody.
I could mention a sixth type with maybe several mature implementations but those languages are usually in the mainstream or well known, so you could gain enough knowledge about them with 5 minute goggling.