A conversation with the Go team

His is an extreme case of "no true Scotchman" ("no guy that truly tried Go complains about Generics...") and confirmation bias (since those that stick to it, are happy with the status quo) together...

Lots of people have both tried Go, legitimately, and are still concerned about lack of Generics. I've read several that have done so, and have tried it myself and would like Generics. But sure, I could use it, and even enjoy it, even without Generics. That doesn't mean I'm perfectly happy with the situation.

True, Rob's jokes can be very dry and subtle. If he ever looks at the golang-nuts Google group [1] (which he evidently does) there's no way this couldn't have been sarcasm. Many questions from newbies touch on the topic of generics.

[1] https://groups.google.com/forum/?fromgroups#!forum/golang-nu...

Masterfully executed. Especially delightful is that the first response is "No one is likely to debate this with you", which is promptly followed by 9 pages of discussion.

Generics are used to defer type setting from compile time to run time, allowing for flexible, yet type-safe constructs.

The classic example is a list (in a strongly-typed language) - without generics you would create specialised strongly-typed list classes - you could have a StringList (only strings), an IntList (only ints), etc.

Using generics you can define a single list class of type <T>, where <T> is any type. Then at runtime you would create a List<String> or a List<Int>. Same outcome, less code, easier to maintain.

MSDN has a good intro to C# generics - http://msdn.microsoft.com/en-us/library/ms379564(v=vs.80).as...

They are less appropriate in dynamic languages, as type-safety isn't a compile time concern.

Example of generics: In Delphi, you have TList. It stores any TObject, but it's not type safe, so if you store something like TPerson in it, you have to cast it every time:

    List := TList.Create();
    Person := TPerson(List[0]);

With generics, you would have something like:

    List := TList<TPerson>.Create();
    Person := List[0];

The TList<TPerson> class would be compiled at compile time and offer the same kind of type safety as, say, an array.

In C++ it would be something like (simplified):

    template <class T>
      class TList {
        private:
          T[] elements;
        public:
          void add(T value);
          void remove(T value);
          T operator[](int index);
      };

This extends to other declarations. For example, in C++ you can have generic functions. So you can have a functon max(a, b) which works on any type, for example.

Generics is essentially about enhancing compile-time type safety and reusing code. By giving the type system more intelligence, more checks can be performed at compile time, and code can use the same logic across multiple types instead of having to be reimplemented for each type.

Incidentally, Delphi has had generics since 2007 [1]. I haven't used Delphi since version 5, so I haven't tried it out, but it looks fairly similar to the generics in C#.

[1] http://en.wikipedia.org/wiki/Generic_programming#Genericity_...