News for hackers. Stuff that matters.
Re:Object-Oriented Programming: A Disaster Story by lmm on Wednesday January 20, 2016 @05:17AM (#10937091)
* Ad-hoc polymorphism is valuable, and objects represent a clear way to express it

* Thin wrappers that slightly change functionality are often a business requirement, and "extends" inheritance provides an easy way to express them

* Having data associated directly with the corresponding state can make exploratory programming easier (e.g. suppose I have a library for accessing the Facebook API, so I fetch my user info. In OO style it's immediately clear what I can do with my user info, because it's all methods on the object; in functional style it's less clear)

Re:Object-Oriented Programming: A Disaster Story by alkonaut on Wednesday January 20, 2016 @05:25AM (#10937131)
> Thin wrappers that slightly change functionality are often a business requirement

I doubt that a business requirement stipulates how something is implemented, but thin extensions are often an apparently convenient way of quickly getting the slightly different behavior of the business requirement. Whether or not it's a good idea just because it is quick and convenient I think isn't clear. From a business perspective this is one of the false benefits -- if the problem is apparently solved quickly, but the maintenance is harder afterwards, it may not be the best idea. I'd bet sum types + common pure functionality accomplishes the same thing with lower maintenance cost.

> Having data associated directly with the corresponding state can make exploratory programming easier

I agree that many functional languages have definite drawbacks in terms of exploratory and self documenting programming. "Methods" on types are to me a definite requirement also for an FP language because of autocomplete/documentation/ergonomics. To , me writing v2 = Vector.normalize(v1) is vastly inferior to v2 = v1.normalize(). This is syntactic sugar of course, but important sugar. Neither is "OO" though: associating methods as postfix can be done regardless.

Re:Object-Oriented Programming: A Disaster Story by lmm on Wednesday January 20, 2016 @05:42AM (#10937190)
> I'd bet sum types + common pure functionality accomplishes the same thing with lower maintenance cost.

Not my experience - most functional languages make it much harder than it should be to say "this is exactly an X except that it prints differently".

> I agree that many functional languages have definite drawbacks in terms of exploratory and self documenting programming. "Methods" on types are to me a definite requirement also for an FP language because of autocomplete/documentation/ergonomics. To , me writing v2 = Vector.normalize(v1) is vastly inferior to v2 = v1.normalize(). This is syntactic sugar of course, but important sugar. Neither is "OO" though: associating methods as postfix can be done regardless.

Well, if a feature is present in all mainstream "OO" languages and not in any mainstream "functional" languages then I'll call it "OO". I'd be very interested to see a functional language with good support for this kind of thing though.

Re:Object-Oriented Programming: A Disaster Story by alkonaut on Wednesday January 20, 2016 @05:55AM (#10937234)
> Not my experience - most functional languages make it much harder than it should be to say "this is exactly an X except that it prints differently".

yes, FP usually makes it harder. The question is whether the extra effort is worth it over a 10 year period or not, i.e. does the FP solution maintain more easily than the OO one? I'm not saying it does, just saying the answer isn't clear after the implementation, only much later.

> I'd be very interested to see a functional language with good support for this kind of thing though.

F# is a good example.

Re:Object-Oriented Programming: A Disaster Story by catnaroek on Wednesday January 20, 2016 @03:31PM (#10941108)
> Not my experience - most functional languages make it much harder than it should be to say "this is exactly an X except that it prints differently"

That's because this is the wrong thing to say in the first place - it dilutes the very meaning of “type”. You should factor out the common parts, and only then say X prints this way, Y prints that other way.

Re:Object-Oriented Programming: A Disaster Story by lmm on Thursday January 21, 2016 @05:12AM (#10944317)
The overhead of adding another type is nontrivial (which maybe is a problem in itself; nevertheless, here we are). For business-critical distinctions it's worthwhile. For differences that only matter in one or two places, or for less-critical functionality (e.g. GUI tweaks) it may not be.
Re:Object-Oriented Programming: A Disaster Story by danieldk on Wednesday January 20, 2016 @05:38AM (#10937176)
Ad-hoc polymorphism is valuable, and objects represent a clear way to express it

You can do ad-hoc polymorphism using type boxes (existentially quantified type classes). Of if you think this is an anti-pattern, just plain old data structures plus (first-class) functions:

https://lukepalmer.wordpress.com/2010/01/24/haskell-antipatt...

Thin wrappers that slightly change functionality are often a business requirement, and "extends" inheritance provides an easy way to express them

So does composition.

In OO style it's immediately clear what I can do with my user info, because it's all methods on the object

The problem with this is discussed in the linked article.

Edit: I see that you do Scala, so all of this is not news to you ;).

Re:Object-Oriented Programming: A Disaster Story by lmm on Wednesday January 20, 2016 @05:45AM (#10937198)
> So does composition.

I've found composition is always much more heavyweight than it should be. "Deriving" helps a bit, but it still feels very manual when your use case is along the lines of "I have this thing with 6 behaviours and now I want a wrapper that changes just one of them very slightly".

Re:Object-Oriented Programming: A Disaster Story by romankolpak on Wednesday January 20, 2016 @06:07AM (#10937268)
A more practical way of discussing this would be a concrete example of a business need, implemented in both paradigms - object-oriented design relying on inheritence and then a more typical to FP design based on composability. Then by simply comparing the two we could draw some conclusions about code size, simplicity, maintainability and so on.
Re:Object-Oriented Programming: A Disaster Story by lmm on Wednesday January 20, 2016 @06:40AM (#10937398)
There's no way to do a small example because it's an issue that only happens when you already have a large codebase. Say you have a large, complex object - and you can argue that's already assuming something about your development path. And then you want to offer a variant that has slightly different behaviour (say it has an extra line when you print it, and one of the calculation methods should return 2x as much for this variant, and another method should return 0.5x as much - and again, that's making intrusive assumptions about the wider design). That kind of scenario really does happen all the time in real-word functional code (at least for me), but it's impossible to make it a rigorous example where partisans can't say "don't do that then".