They're popular only on the Internet for a reason.

Didn't anyone of you listen to the "Foxtrot" or "Nursery Cryme" album ???

> Do you think str.Substring(1, str.Length - 2) is any better, especially given that it's not even clear whether the second argument is a length or an absolute position?

if it were an absolute position, the name of the method should be slice, not substring.
the only reason there's any confusion about this is that javascript called their slice method substring.

> > * You're required to specify types for properties, return types of methods, and types of lambda expressions if assigned to a variable (i.e. var f = x => x + 1 is illegal).
> > * The syntax for an array literal is new int[] { 1,2,3,4 } instead of [1,2,3,4].
> these two are the same thing. type safety is a good thing.

It's possible to implement both of those in a type-safe manner without the programmer having to hold the compiler's hand. The problem is that C#'s type inference is too limited.

> that's just simpler, saner syntax. seriously, "splat"? "[1:-1]"? what is this, perl?

Comment too long; full version here.

> * You're required to specify types for properties, return types of methods, and types of lambda expressions if assigned to a variable (i.e. var f = x => x + 1 is illegal).
> * The syntax for an array literal is new int[] { 1,2,3,4 } instead of [1,2,3,4].

these two are the same thing. type safety is a good thing.

> * Lots of little things such as params keyword instead of splat, lack of str[1:-1], etc. all add up.

that's just simpler, saner syntax. seriously, "splat"? "[1:-1]"? what is this, perl?

> * C# has no free functions. They're all (possibly static) methods of a class, and classes themselves can't be ‘imported’. The .NET class library is also excessively verbose in places.

Comment too long; full version here.

Try D, it's a lot like C#, only less stupid. I've found it to be a quite comfortable language for mid/high-level programming, and although it's statically typed, it also has some degree of inferencing, which if you combine with templates, you get a lot of the benefits of duck-typing without many of its problems (like runtime errors about wrong types).

import std.stdio;
int main(char[][] args)
{
    // more type inferencing for 'n' and 'arg'
    // also note use of 'length'
    foreach (n, arg; args[1 .. length])
            writefln(n,
                     // inline array declaration

Comment too long; full version here.

• You're required to specify types for properties, return types of methods, and types of lambda expressions if assigned to a variable (i.e. var f = x => x + 1 is illegal).
• The syntax for an array literal is new int[] { 1,2,3,4 } instead of [1,2,3,4].
• Lots of little things such as params keyword instead of splat, lack of str[1:-1], etc. all add up.
• C# has no free functions. They're all (possibly static) methods of a class, and classes themselves can't be ‘imported’. The .NET class library is also excessively verbose in places.
• The lack of duck typing necessitates declaring and implementing interfaces.

Most of its verbosity comes from its historical lack of type inference and its lack of higher-kinded polymorphism. The C heritage adds the minority of it, I'd say.

Also, Markdown seems to require that the asterisks used to form lists don't have any whitespace in front of them. How intuitive.

too bad it doesn't seem to work.

?- satori(ruby).

no

IF YOU DONT POST THIS TO 5 BROS THEN YOU ARENT A BRO

# -*- ruby -*-
def satori
  []
end
$hybt = satori()
def yhbt?
  true unless $hybt.join != ("yhbt")
end
def method_missing(abelson,*harold)
  $hybt << abelson.to_s[0,1]
  satori = satori()
  if yhbt?
    %w{Gerald Jay Sussman SICP}.each_with_index{|snake, grunnur| satori[grunnur] = snake.length; @gjs = snake.upcase if grunnur == 2}
    ((satori[0]+satori[3])*(satori[1]+satori[2])*satori[1]).times{puts @gjs}
  end

Comment too long; full version here.

I tried C#, was a bit too verbose for my tastes. IronPython is pretty zippy, though. And having access to all the CLR goodness was a blast.

However, when all is said and done, I prefer C-compiled programs over bytecode or interpreted. Thus, Genie.

Make that six people. Though I've got my eye on Genie. It's fucking fast.

# -*- py -*-
def factorial(n):
    if not isinstance(n, (int, long)): raise TypeError("expected %s but got %s" % ((int, long), type(n)))
    if n < 0: raise ValueError("%d is less than 0" % n)
    if n < 2: return 1
    global N
    p = r = N = high = 1
    h = shift = 0
    def floorlog2(n):
        a = 0
        while n > 1:
            n >>= 1
            a += 1
        return a
    log2n = floorlog2(n)

Comment too long; full version here.