Yes exactly. Although I think with Generics they will probably come around at some point. If you read the link I posted they do recognized there are unsolved cases without Generics and while some people DO say "just rewrite your collections over and over when you can't use maps/slices", others recognize that this will lead to redundant code which is not something you want in a language touted for its maintainability.

Other problems though such as default function parameters are less likely to be addressed (it seems to me). This is a problem because it means lots of code will be written in which there are implicit defaults (just pass 0!) that are not well-understood or guaranteed by the interface. The answer there is "just write another method with a different name and parameters". Ok so now I have to think of sensible names for the methods that are exactly the same as another method except they apply defaults...and write and maintain more code of course - especially if its in an interface you re-use.

> Other problems though such as default function parameters are less likely to be addressed (it seems to me).

It's unlikely to be addressed given that Google style guide forbids using default function parameters even in C++.

> This is a problem because it means lots of code will be written in which there are implicit defaults (just pass 0!)

"Just pass 0" is not a good way to implement defaults.

Yes that is exactly my point. But it is what WILL happen in a lot of Go code.

Today I was writing a Skein hash function implementation in Go. Skein can be configured for different purposes (e.g. MAC, KDF, stream cipher, etc.), and it can accept >5 optional arguments. I wanted to expose all these configuration option to users, in addition to providing a simple version that will create hash without configuration. Here's how I solved it (there's prior art in some standard libraries).

I exported this struct:

  type Args struct {
    Key       []byte // secret key for MAC, KDF, or stream cipher
    Person    []byte // personalization string
    PublicKey []byte // public key for signature hashing
    KeyId     []byte // key identifier for KDF
    Nonce     []byte // nonce for stream cipher or randomized hashing
  }

and then provided a function:

   func New(outLen uint64, args *Args) *Hash

Users can easily call it like this:

   h := skein.New(64, &skein.Args{ Key: someKey, Nonce : someNonce })

I like this design a lot.

Plus, with structs as arguments you can easily provide more than one default configurations. For example, if you want to personalize hash for different usages:

   var FileHashConfig = &skein.Args{ Person: []byte("file hash for MyApp") }
   var MessageHashConfig = &skein.Args{ Person: []byte("message hash for MyApp sync") }

and use them:

   h := skein.New(64, FileHashConfig)

(Note: Args is a bad name for general usage -- I called it like this only because Skein authors call these "arguments", and "configuration" is reserved for something else.)

There are a few specified usages for Skein with arguments, so to avoid making users of my library read the Skein paper, I wrote "constructors" for them:

  // NewMAC returns hash.Hash calculating Skein Message Authentication Code of the
  // given length in bytes. A MAC is a cryptographic hash that uses a key to
  // authenticate a message. The receiver verifies the hash by recomputing it
  // using the same key.
  func NewMAC(outLen uint64, key []byte) hash.Hash {
  	return hash.Hash(New(outLen, &Args{Key: key}))
  }
  
  // NewStream returns a cipher.Stream for encrypting a message with the given key
  // and nonce. The same key-nonce combination must not be used to encrypt more
  // than one message. There are no limits on the length of key or nonce.
  func NewStream(key []byte, nonce []byte) cipher.Stream {
  	const streamOutLen = (1<<64 - 1) / 8 // 2^64 - 1 bits
  	h := New(streamOutLen, &Args{Key: key, Nonce: nonce})
  	return newOutputReader(h)
  }

Simple.

So depending on the algorithm you are using, you are going to leave some of these fields in the struct as null/empty?

To me this is the whole issue. Of course if we have knowledge outside the method declaration about what values can be left 0, then we can pass the correct ones as needed. But the interface is ambiguous about when that is acceptable, and the implementation can change without changing the interface.

According to the mail lists I've read on the subject, the correct way to implement your algorithms in Go would be for each to be a separate method. And indeed that is the only way in Go to support a fully specified interface.

> So depending on the algorithm you are using, you are going to leave some of these fields in the struct as null/empty?

In Go, when you create a new variable, it's automatically set to the null/zero value. So in this case, they would be nil.

Which is not necessarily the default value you want for them.

So not the same thing with default values at all.

With this struct interface you just implement "optional" values...

For default values, there are at least two choices. The first one I mentioned -- just create a variable and export it. Users can pass it:

In skein package:

   var DefaultHash = &Args{ ... } // the default args you want

Users will call it like this:

   skein.New(32, &skein.DefaultHash)

Another way, better for some cases, is have methods on arguments struct, like in base32 package from stdlib http://golang.org/pkg/encoding/base32/

  base32.StdEncoding.DecodeToString(...)
  base32.HexEncoding.DecodeToString(...)

In most cases (but now all), there are better ways to design API than stuff them with default arguments, which make functions behave unexpectedly if you forget something.

But maybe we should talk about specific cases? What are the examples of functions which need to accept default arguments? Maybe I can try to convert them into something reasonable in Go?

That is awful for anyone attempting to re-implement your API. It is totally unclear what field combinations are valid, and in time the situation is only going to get worse.

There are no invalid combinations of fields in this case, any combination is valid. If there were invalid combinations, of course, this wouldn't be a nice API.

'Why do they assume that people complaining haven't used the language "enough"'?

Because they do not share your belief that Go has "fundamental issues and well understood design issues".

If they did then your argument reductio ad absurdum would make sense. However, they don't; it does not.

This post by Russ Cox (a co-inventor of Go) describes leaving parametric polymorphism out as "slowing down programmers". http://research.swtch.com/generic

I think it's safe to say they are aware of the issue and consider lack of generics a negative (because it slows you down, duplicates code, adds type unsafety, etc.). They don't have a solution they like yet.

It would take more than:

(1) them not believing that Go has design issues

for my argument to not make sense. It would need both (1) and

(2) them being right about said belief

for my argument to be invalid. And while (1) might hold, (2) is highly debatable.

I don't write any Go, but 'you are doing it wrong, we use a different idiomatic style to handle that' is not a necessarily invalid thing to say.

Idiomatic is not necessarily better. "Idiomatic" C code of the eighties would be considered atrocious now.

And idiomatic Java code (Factory of proxies of singletons) is laughed at.

And not a lot of people are fond of idiomatic Ruby code, which tends to rely on "magic" (or "action at a distance").

Sometimes idiomatic is good, sometimes it's bad. Let's not cargo cult.

I am not cargo-culting. I am saying that it is not invalid to say to someone 'you're doing it wrong, if you just use a different style that does not become a problem.'