I can understand the speed part but maintainability? Sounds interesting, would you like to elaborate?

Static typing is a godsend when you're working with code that you only vaguely remember from the last time you worked with it a year ago. It also gives me much more confidence when refactoring: the compiler will find the callsites I missed.

C++ also has a great feature which a lot of more modern languages (Java, Python) have forgotten about: const correctness.

    class Foo {
        type_t getValue() const;
    }

When I call foo.getValue(), I can be certain [1] that foo has not been mutated.

[1] In C++, things like memset((void*)this, val, 1024) are always possible.

>const correctness

I love that C++ programmers still believe in the false gods of the const keyword.

Zen: reflect upon the meaning of a const volatile pointer.

-> exits stage right

Won't proper testing help on that matter too?

I've worked on rather big projects in Ruby and Javascript, and testing always managed to keep things sane. Static typing helps you refactor things or make sure certain variables are the correct type, but in the grand scheme of things, I'm not sure type casting is the major source of bugs/errors in any system

I do like Python but haven't used it for anything more than a few thousand lines.

The dynamic nature puts many errors into the runtime stage and increases verification complexity. Can be limited by static code checking, but grows cumbersome.

What do you use for longer programs?

Go if possible, C++ otherwise.

Duck typing makes for difficult debugging in large programs.

python's loose typing can cause some problems when new people start contributing to a sizeable project, that can be caught earlier in languages with stronger/earlier type checking.

But isn't Java the middleground between those two?

Not even close.

I'd say Go is, though.