I am an avid gopher, but this is not a useful response. Believe it or not, there are many places and reasons where Python works out better than Go, and making it a bit easier to use Python in those situations is valuable.

You're getting downvoted, but I think you have a point. Any attempts to enact type-checking in a language that doesn't require it is doomed to failure. You'll get all the safety of a dynamic language, with the flexibility of a typed language.

> You'll get all the safety of a dynamic language, with the flexibility of a typed language.

That sounds a pretty good description of Go, so I'm wondering what his point is in the first place.

Go is neat, but why not just use Haskell? (etc.)

Monads

Or more specifically, how non-intuitive it is to use the IO stuff

I don't care what it uses, or what is it called, I care about being able to use it with what I know

So yeah, I'll go for Go instead of Haskell

The IO stuff has almost nothing to do with monads.

It is unfamiliar, but if you use static typing, at least reap the benefits of better error checking, no runtime null dereferences, etc.

Yeah, because why would we ever need the compiler to help us identifying operations which make it harder to reason about our programs!

Haskell is ok, but you should check out the dynamic nature of Python

I think that the dynamic nature of python is why some folks prefer haskell over it.

yeah, that was my joke... no one got it. basically I'm talking about the never ending hunt for a perfect language

Well, not that many. So that settles it then.

That is why i said some.

You should check out the dynamic nature of Typeable.

"The module Data.Dynamic uses Typeable for an implementation of dynamics."

http://hackage.haskell.org/package/base-4.7.0.0/docs/Data-Ty...

The case of a large, already existing Python codebase comes to mind.

You make Python sound like FORTRAN. :)

err...It's a tradeoff.

I think when the first dynamic programing language was invented, the loose typing system must be thought as a big advantage.

Type checking is necessary in some cases, but I really enjoy dynamic typing a lot. So I think a bit tradeoff like this is acceptable. After all, we have to tradeoff everywhere when it comes to computer science such as the time-space tradeoff of an algorithm.

I think people who enjoy dynamic typing have had bad experiences with bad static type systems earlier (C, C++, Java).

Once you use a good static type system (ML, OCaml, Haskell) you see that dynamic typing isn't responsible for the joy, but the ability to express rich ideas without repeating redundant type declarations.

I would like to know why in every post about Python on HN there's someone shouting "just use Go"!

It seems like quite a few people who are used to dynamic languages have found out that static typing and verbosity aren't strictly synonyms by using Go.

Static-typed languages are not very good for scripting and "gluing" systems.