What characteristics do we use to describe languages? What's "dynamic" and what's "static", and to what languages can we apply this label? How does this help us compare-and-contrast different languages?
From Jay (our presenter):
On Software Language Design: Hits, Misses, and Trade-Offs (formerly Language Attributes Discussion)
There are many websites that compare different programming languages in different ways.
* Sites that offer program snippets for different languages (e.g., rosettacode.org).
* Sites that compare language syntax or semantics.
* In tabular form (e.g., http://hyperpolyglot.org/).
* Diagrammatically (e.g., http://dafoster.net/articles/20...)
* Sites that disclose “hidden features” (e.g., http://beerpla.net/2009/06/21/h...)
But a rote comparison of language attributes is only a first step. Software engineers should strive to be able to compare features across languages, know what alternatives exist, and what trade-offs they represent. And most of all, how features can best work together to suit the use cases of targeted portions of the developer community. There have been many articles explaining differences between the most popular languages, C++ and Java, partially due to Stroustrup's The Design and Evolution of C++, and to Java's JCP & JCRs. So I'll try to focus elsewhere.
Some language design hits:
* Most language innovations over the years: IOC, QuickCheck, Templates, VMs, xUnit, etc.
* Language design evolution support: JCP/PEP, Boost (C++ features).
Some language design misses, or ideas that have jumped the shark:
* NULL in most OO languages (not including NULL in SQL)
* C++'s export keyword (Turned out to be less useful than hoped.)
* Deprecated features
Some other things that should be kept in mind when comparing languages and language features:
* Punctuation and syntax are limited resources.
* Most common mistakes made by experienced users? (= vs. ==, forgetting semi-colon, etc.)
* Undefined behavior. (C has lots of this, but it's less prevalent in newer languages.)
* Support for OO, FP, GC, DSLs, higher types & kinds, (co-)monads, etc.
* Turn implicit code into explicit, then back to implicit differently. For example, type-checking.
* Turn typographical conventions into syntactic rules (e.g., Capitalize type names).
* Turn syntactic conventions into semantic rules (e.g., have syntax constraints allow the meaningful addition of non-ASCII characters to identifier names).
Lastly, I'll present some “crazy ideas” for new languages or modifications to existing ones, in the hopes of fostering some lively discussion.
As I said above, feedback and/or discussion welcome.