I read your essay on programming languages. I found it was awesome btw.

I saw you made the comment `o be concrete - object oriented programming is easy in python, because it's possible to program methods of an object in a way that doesn't assume a particular representation.`

I thought you would be really interested in usage of polymorphism in python (http://neverworkintheory.org/2016/06/13/polymorphism-in-pyth...).

Quote from the article: `Our findings show that the receiver in 97.4% of all call-sites in the average program can be described by a single static type`.

It looks like even when that restriction is removed it doesn't really help that much.

Another great podcast on evidence based programming: https://www.functionalgeekery.com/episode-55-andreas-stefik/

Evidence-based programming language design : a philosophical and methodological exploration: https://jyx.jyu.fi/dspace/handle/123456789/47698

Is another great read if you've got the time.

Thanks for the links :) I've saved them and hope to eventually make my way through them

Not saying its a key part. Im in the camp you better have a damn good reason to use inheritance that composition will suffice.

The whole notion that everyone has their own perspective on oop makes it a mute point.

Actually that's "moot point": http://www.dictionary.com/browse/moot-point

But yes, the number of variant perspectives on OOP make it a less descriptive term than would be ideal.

Or a cow's opinion!

No but seriously, I think both you and hackits make it clear that there's a lot of discussion over what OOP actually is. Which makes me curious: is there any research on the characteristics of OOP as it implemented in practice across languages? I'd be very interested in such research, because it seems to me that what is possible is often not practiced.

So, for example, Ruby might be all about 'message passing' as others, and all the tutorials and books I've read indicate, but in practice it might be indistinguishable from just calling methods on objects, or whatever distinguishes message passing from other OOP styles.

If no such research exists, how difficult would it be to scan codebases on Github to analyse this? I might be wrong, but it seems like this would be a worthwhile investigation: how do people actually use languages and what is 'OOP' or 'FP' actually like in codebases that claim to be one or the other.

Otherwise we're just getting tangled up in definitions and it's all a moo point.

As of a research paper by Kaijanaho, Antti-Juhani (https://jyx.jyu.fi/dspace/handle/123456789/47698)

Since 1960 till 2012, there are only 22 research papers that used empirical evidence with randomised cross over studies for language design.

As of which, Class inheritance had 4 randomized controlled experiments. With a collection of other studies. That is mostly of the information I have come across.

There is a research paper on Java that looked at how programmers use inheritance. It's a interesting read and its a good source. (https://researchspace.auckland.ac.nz/handle/2292/16840)

I think Google published another paper looking at development time and I believe the result was the biggest time consumer for programmer was dependencies not necessary the programming langue.

I'm not sure measuring how programmers use programming languages would help you gauge whether those languages are any good. It's like measuring the way people rode bicycles in 1880 - that would never lead you to invent the car.

> Otherwise we're just getting tangled up in definitions and it's all a moo point.

I agree. I would say a lot of things people do in OOP isn't really OOP it's just object modeling principles. You can apply the same principles in a different language without notions of objects/classes (javascript) comes to mind.