Comments by "Brent Jacobs" (@br3nto) on ""O.O.P. Looks Like Functional Programming When Done Right!" | Michael Feathers On OOP vs FP" video.

What do you mean when done right? OOP is always functional programming. The instantiation of a class is effectively the creation of a closure and a callable function (or functions depending on how many methods the class has), which can then be passed around and referenced and called at some later time. OPP was doing functional programming before functional programming was even a thing.
4
@ContinuousDelivery yes, fair enough with the timings. But it doesn’t matter if the written OOP is good or bad, it can still always be considered as functional programming. Even though it’s not what people think of when thinking about functional programming, creating an instance containing data which can be passed around around and used and manipulated at any future point in time, it has the same effect as functional programming.
2
@ApprendreSansNecessite Maybe I don’t seem to be, but I am actually very open. I love learning and discussing ideas. I think I seem closed to you because I haven’t been convinced yet by your argument that I’m wrong. So, I think maybe we’re talking about two different parts of the Functional Programming ideology? The part of that ideology where it says functions are first class citizens, I’m saying that an object meets that criteria. Nothing more, nothing less. Referential transparency, immutability, and any of the other properties can be codified within the class to give it that deeper adherence to the more pure and algebraic parts of the functional programming ideology. That is, it’s the way you write code that matters. So, I don’t think it’s true at all that “the moment you introduce that stateful closure you literally loose every single feature of functional programming”. Also, at some point in our code, there has to be mutability and state that is changed, otherwise you don’t have a useful program. At some point I want that 1 to become a 2 or that “Hello World!” to become a “Goodbye World!”. The more mathematical parts of the Functional Programming ideology seems to ignore that part. I’m sorry but I don’t know what I’m supposed to be thinking upon i your triangle/square example.
2
@nythrox3047 it’s not like saying that at all. Well, maybe, if the CPU instructions provide OOP and FP concepts. I guess one of my implicit points is that saying code that is writing in a “functional programming” kind of way isn’t a good description of what is good code because technically all OOP is FP and I’m sure all FP code is not good code. The more I read up on FP though the more I realise it’s an ideology. Which parts of that ideology are the good parts that automatically make a certain piece of code good? I’d wager that there are equal amounts of really shit hard to understand and reason about highly coupled poorly written FP code just like there is with OOP code. Which, if true, means it’s not FP that makes code good but certain qualities mentioned within that ideology. I mean JS code is FP code and not all JS code is good code. Or maybe I just read too much into the title. I assumed the title meant good OOP looks like FP which is good. But I think I added the which is good part myself.
2
@nythrox3047 maybe that’s what they implied, but they didn’t say that explicitly in this or the original vid. So yeah I took it to mean the normal meaning of functional programming, which starts with first-class functions. Sorry? OOP starts at that FP point. There is no reason all the other functional programming qualities that have been talked about in this thread can’t be used too. So my point is, those qualities talked about aren’t specific to functional programming. They’re specific to just programming whether using FP or OOP. I guess it’s just that FP came first. Good code doesn’t look like FP, because FP doesn’t automatically mean good code; FP code can be really shit; good code looks like <insert specific qualities that don’t relate to a specific programming paradigm here>. Make sense?
2
@ApprendreSansNecessite data is data regardless of what it’s context or purpose is. I think your point about conflating types and contexts of data is more about the quality of a program, not whether it is functional programming or not. Mixing or separating context and purpose can be done in any paradigm.
1
@ApprendreSansNecessite the second a feature like first class functions and higher order functions is introduced, the function is no longer stateless. The function closes over some data that can either be used or manipulated by the function. This is no different to instantiating a class and calling a method on it. Pure functions on the other hand are no different to static methods or methods that could be static but don’t have that keyword. It’s for those reason I can confidently say that OOP is FP.
1
@ApprendreSansNecessite yeah, I completely agree with you about your comment to my earlier comment. Of course code can demonstrate properties such as immutability just by not mutating any data it has access to. I think what I was trying to say is that first class functions etc do have a state which may or may not be accessed and or modified.
1
@ApprendreSansNecessite if anything, it’s the anonymous classes of Java that demonstrates the true power of OOP used in a functional programming kind of way. And definitely also Java’s enum constructors. I’ve never come across anything as amazing and powerful as those two language features.
1
@ApprendreSansNecessite lol yes, exactly, that when limiting it to one method and when only using immutable variables is exactly like using a lambda! I find this interesting too… If a mutable variable is used, it can be thought equivalent to a state machine, or if multiple variables used, a non-deterministic state machine. I find this concept interesting because there is an entire branch of maths/science around these concepts and how they relate that could be used to specify well defined rules to refactor code or perhaps how to write code well. Yeah, ok I’ve never had a chance to look at Rust. Your recommendation makes me curious. Thanks. Yes, I assume that’s true that I can’t really know what FP looks like when I have the freedom in OOP to do different things. E.g. to understand your last comment about breaking FP flow.
1