3 ms·

>> Generics have nothing to do with inheritance and the factory pattern. > Where do I say such a thing? I'm saying that generics are both overrated and overuse

>> Generics have nothing to do with inheritance and the factory pattern. > Where do I say such a thing? I'm saying that generics are both overrated and overused. It looks like that's what you're suggesting here: > Inheritance is overrated, and the factory pattern is often overused. Both of those happen with generics. --- > Where do you get that Factories are "a workaround for functions not being able to be freestanding?" A factory is, conceptually, a function of some set of inputs that returns a new instance - which is, of course, exactly what a constructor is. Now, it's not always appropriate for a class to know every single way in which it might be assembled, so such responsibility is usually lifted out - the question is where to put it. We already have constructors, and those are functions, so it would seem reasonable that we could just write method similar to a constructor, place it in some other namespace (perhaps in a completely different package/module), and then pass that along to the component that needs to create these new instances. For languages like Java, the problem is that functions are not first class - you can't directly pass along a method/function like (Conf -> SomeService), so instead, it's common to create some special type, like SomeServiceFactory. If, for comparison, you take a look at Scala/Haskell/C#/etc, you'll wont often spot /.*Factory/ anywhere, because a function (with the ability to close over free variables) is much more concise, and doesn't require defining new types (e.g. SomeServiceFactory, versus Function<Conf,SomeService>). I think that, seen in this light, the practice of defining dedicated factory classes is a rather clumsy approach necessitated by the design of the underlying language.

stcredzero 13y ago
It looks like that's what you're suggesting here: > Inheritance is overrated, and the factory pattern is often overused. Both of those happen with generics. Non-sequitur here. To me, it's clear that I'm saying that generics are overrated and overused. Your interpretation makes no sense! For languages like Java, the problem is that functions are not first class - you can't directly pass along a method/function like (Conf -> SomeService), so instead, it's common to create some special type, like SomeServiceFactory. Another non-sequitur here. Factory pattern was originally popularized in the GoF book as a way of providing an opportunity for polymorphism. If, for comparison, you take a look at Scala/Haskell/C#/etc, you'll wont often spot /.Factory/ anywhere, because a function (with the ability to close over free variables) is much more concise* Old hand at Smalltalk here -- over 10 years. You don't often see Factory classes in Smalltalk. We also have very easy and nimble closures over variables in the context they're defined. I still don't get what you're on about.
- Sssnake 13y ago
  >Non-sequitur here. To me, it's clear that I'm saying that generics are overrated and overused. Your interpretation makes no sense! You are making the non-sequitur. His interpretation is the only one that makes sense. It is not clear at all that you are saying what you claim you are saying. You are in fact not saying anything like it. You are saying two things you don't like happen with generics, but that is completely false.
  - stcredzero 13y ago
    Okay, now you just sound like you're trolling. Please point me to the grammar rule that says my referents can't be verbs.
    - Sssnake 13y ago
      What do you mean "now"? That was the first thing I said to you. You may wish to consider that when many people are telling you that what you said was nonsense, it may not be that all of them are crazy.
      - stcredzero 13y ago
        What do you mean "now"? That was the first thing I said to you. So you are trolling, and you still haven't pointed out such a rule.
- cstrahan 13y ago
  >> Inheritance is overrated, and the factory pattern is often overused. Both of those happen with generics. > Non-sequitur here. To me, it's clear that I'm saying that generics are overrated and overused. Your interpretation makes no sense! Ok, now I understand what you're saying. As an aside, I would suggest that most people (as is evident in this comment thread) would not interpret your statement the way you intended. >> For languages like Java, the problem is that functions are not first class - you can't directly pass along a method/function like (Conf -> SomeService), so instead, it's common to create some special type, like SomeServiceFactory. > Another non-sequitur here. Factory pattern was originally popularized in the GoF book as a way of providing an opportunity for polymorphism. I agree (re: polymorphism), but I don't think that contradicts what I'm saying; functions with parametric polymorphism (with support for {co,contra,in}variance) provide the same benefits of class polymorphism in this context. > Old hand at Smalltalk here -- over 10 years. You don't often see Factory classes in Smalltalk. We also have very easy and nimble closures over variables in the context they're defined. I still don't get what you're on about. You're absolutely correct. However, my point was that in statically typed languages, generics are conducive to favoring closures over factories classes and inheritance. But, now I realize that we were arguing two different things.

stcredzero 13y ago

It looks like that's what you're suggesting here: > Inheritance is overrated, and the factory pattern is often overused. Both of those happen with generics. Non-sequitur here. To me, it's clear that I'm saying that generics are overrated and overused. Your interpretation makes no sense! For languages like Java, the problem is that functions are not first class - you can't directly pass along a method/function like (Conf -> SomeService), so instead, it's common to create some special type, like SomeServiceFactory. Another non-sequitur here. Factory pattern was originally popularized in the GoF book as a way of providing an opportunity for polymorphism. If, for comparison, you take a look at Scala/Haskell/C#/etc, you'll wont often spot /.Factory/ anywhere, because a function (with the ability to close over free variables) is much more concise* Old hand at Smalltalk here -- over 10 years. You don't often see Factory classes in Smalltalk. We also have very easy and nimble closures over variables in the context they're defined. I still don't get what you're on about.

Sssnake 13y ago
>Non-sequitur here. To me, it's clear that I'm saying that generics are overrated and overused. Your interpretation makes no sense! You are making the non-sequitur. His interpretation is the only one that makes sense. It is not clear at all that you are saying what you claim you are saying. You are in fact not saying anything like it. You are saying two things you don't like happen with generics, but that is completely false.
- stcredzero 13y ago
  Okay, now you just sound like you're trolling. Please point me to the grammar rule that says my referents can't be verbs.
  - Sssnake 13y ago
    What do you mean "now"? That was the first thing I said to you. You may wish to consider that when many people are telling you that what you said was nonsense, it may not be that all of them are crazy.
    - stcredzero 13y ago
      What do you mean "now"? That was the first thing I said to you. So you are trolling, and you still haven't pointed out such a rule.
cstrahan 13y ago
>> Inheritance is overrated, and the factory pattern is often overused. Both of those happen with generics. > Non-sequitur here. To me, it's clear that I'm saying that generics are overrated and overused. Your interpretation makes no sense! Ok, now I understand what you're saying. As an aside, I would suggest that most people (as is evident in this comment thread) would not interpret your statement the way you intended. >> For languages like Java, the problem is that functions are not first class - you can't directly pass along a method/function like (Conf -> SomeService), so instead, it's common to create some special type, like SomeServiceFactory. > Another non-sequitur here. Factory pattern was originally popularized in the GoF book as a way of providing an opportunity for polymorphism. I agree (re: polymorphism), but I don't think that contradicts what I'm saying; functions with parametric polymorphism (with support for {co,contra,in}variance) provide the same benefits of class polymorphism in this context. > Old hand at Smalltalk here -- over 10 years. You don't often see Factory classes in Smalltalk. We also have very easy and nimble closures over variables in the context they're defined. I still don't get what you're on about. You're absolutely correct. However, my point was that in statically typed languages, generics are conducive to favoring closures over factories classes and inheritance. But, now I realize that we were arguing two different things.