Any decent modern general-purpose languages?

Assembly: Unportable. No standardised syntax.
Classical Visual Basic: Some good parts. Shit overall.
C: Shitty standard library. Deficient type system. Can't into Unicode. ``Unportable assembly.''
D and C++: Obfuscated boilerplate languages.
Java and C#: Forced OOP.
Common Lisp: Archaic cons-based library. Writing complex macros is a PitA due to the unlispy quotation syntaxes.
Scheme: CL without namespaces.
Clojure and Erlang: Concurrency is unneeded outside of a few very specific applications. Parallelism is where it's at.
OCaml: Great language, only one, deficient, implementation.
Haskell: Academic sex toy.
Forth: Reinventing the wheel over and over.
Ruby: Implicit declarations. Slow as fuck.
Python: Implicit declarations. FioC.
Perl: Brain damage.
PHP: Pretty much shit.
JavaScript: "" == false

It's impossible to list them all but, please, what decent modern general-purpose languages exist?

>>136

I was expecting replies like this. You still put blind faith in compilers and think they're god-like and better than anyone else. That's what the academia always says. But consider that if it was true, I wouldn't be writing this today. I've probably read through more compiler output than anyone else here, and quite frankly, most of it sucks. ICC is the best I've seen, MSVC is a close second, and GCC is far behind. Delphi is... about the worst I've ever seen.

Yes, we don't have a qualifying implementation yet. But someday we might. And with the benefits it would bring, I don't understand why more people aren't concerned with improving the tools they use every day. Instead, they just crank out applications using what is currently available and popular. A possible solution to a problem brought up in this thread:

* include a construct in the language that places constraints on data types. This constraint can be formally checked with static code analysis, tested dynamically with asserts in testing, and then used as a hint for optimization when building the release version. The compiler could consider a violation of the constraint as undefined behavior, and assume its truth when generating optimal assembly. This way, you can get your architecture specific optimizations without creating undocumented and undetectable restrictions on the inputs.

Would be nifty:

* Automate profiling of generated machine code. Select constructs that give the best performance based upon empirical data collected from are large set test runs.

If they're lazy idiots they can let the compiler hold their hand and do everything for them. If they're intelligent they'll find a way to do things more efficiently. It's about letting the programmer exploit her capabilities to the limit.

Lazy and idiotic is all relative. Computer are idiots. But they are far from lazy. A VERY determined idiot may be able to write a better program than you if given a disproportionately larger amount of time to do it in.