I understand that other people have other priorities, so it is only an illustration of possible opinion.
I disagree, but I still think dynamic typing is better. You will eventually want to use the expressivity of dynamic languages, but the dynamic features of Python are only used 5-10% of the time. That 5-10% of the time where you really need dynamic typing is very important, but you can still have a type inferencing IDE like WingIDE for Python that can figure out most type errors statically, and what methods foo has when you type foo . When you are using the dynamic features you can write something like #@ignore to not have the IDE bug you about it. So basically when your Dynamic code looks like Static code you have all of the IDE features of a Static language, but when your code is Dynamic code your IDE can’t help you, but thats because you are writing code that can’t be done in a Static language at all without complex workarounds.

Also on a related note JIT compilers are getting better and better, LuaJIT is about the same speed as JAVA according to the Computer Language Shootout (google for it) despite being as dynamic as Python. JIT compilers do type inference just like IDEs can do type inferencing to change those 90% of cases where you are writing static code in a dynamic language to be statically typed, while still allowing the dynamic features when needed. This means that static code in Dynamic languages runs about the same speed as static code in Static languages, but you get the expressivity of Dynamic languages. Python will eventually get a JIT compiler as good as Lua’s (see the PyPy project). JavaScript right now is also almost as fast LuaJIT with Google Chrome’s V8. Also Clojure on the JVM is pretty fast, and still getting faster.

What ticks me off is that these two arguments of Dynamic languages (speed and lack of IDE support) are both strawman arguments used by clueless Static language proponents. It doesn’t help when you have Dynamic language users just blurt out and say “I DON’T NEED STATIC ERROR CHECKING AND COMPILED SPEED” when this is a false dichotomy. I want SPEED and STATIC ERROR CHECKING, but I don’t need to give up Dynamic features. So basically there is no reason to use Static languages at all, Dynamic languages can have both the good features of Static and Dynamic languages at the same time.

I understand that other people have other priorities, so it is only an illustration of possible opinion.

Unlike Perl and Python, or other scripting language solution approaches, it blazingly compiles/links into a single executable for ease of deployment to the end user.

Deploying script languages solutions to end users is just a mess. You have to insure the user has the right runtime version and often times they’ll need certain C libraries to be installed too, and then for complex apps/tools, there may be many script files involved and you have to deliver the app in such a way that none of the package/module references get screwed up at runtime. Or else buy a commercial SDK from ActiveState to roll Perl or Python apps into a single executable (which, doing that with such solutions is still not a simple endeavour).

The shear simplicity of the Go approach (static linking) is a breadth of fresh air relative to the scripting languages. Plus the compile/link process is lightening fast.

The crown jewels of Go, though, tend to be the goroutines and channels approach to concurrency programming. Facilitating robust, scalable, and low boiler plate concurrent programming will be important in programming languages going forward. Go will be stellar in this regard.

Plus the approach to OOP in Go is rather interesting and refreshing too.

Alas, Go is so young that there’s not (to my knowledge) any IDE support that does code completion yet.

So I guess the right path is the medium path, just as Buddha said.

IMHO, loose coupling isn’t always a good thing. I’ll take Ada over Ruby any day of the week.

It’s more about programming philosophy – Python’s “there is only one way to do it” makes it easy to read *good* code, even though it’s dynamic.

No.

So dynamic typing is something akin loose coupling.