Question

I’m watching a video course/lectures from Stanford. The course is “The Structure and Interpretation of Computer Programs”

In the first OOP lecture, the instructor (Brian Harvey) describes an OOP method as one that gives different answers for the same question, while a function in functional programming gives a certain output for a certain input.

The following code is an example of a method in OOP that gives a different answer each time it’s called:-

(define-class (counter)
  instance-vars (count 0))
  (method (next)
    (set! count (+ count 1))
    count) )

Now although the course is illustrated by scheme, I didn’t pay much attention to the language itself, and so I can’t explain the code; but can’t a similar function “next” do the same thing as this “next” function?
In C, I would declare a global variable, and each time increase it by one when calling next. I know C is procedural, but I’m guessing a similar thing can be done in Scheme.

Answer 1

Well. With all due respect to the lecturer, these are slightly fishy definitions of both “OOP” and “functional programming”. Both terms are consistently used, well, inconsistently, both in industry and academic contexts, not to mention informal use. If you dig a bit deeper, what’s really going on is that there are several orthogonal concepts–different axes along which a choice is made in how to approach a program–that are being conflated, with one set of choices being arbitrarily called “OOP” despite not having anything else tying them together.

Probably the two biggest distinctions involved here are:

• Identity vs. value: Do you model things by implicit identity (based on memory location or whatnot) and allow them to change arbitrarily? Or do you model things by their value, with no inherent notion of identity? If you say x = 4 does that mean that x is an alias to the timeless Platonic ideal of the number 4, or is x the name of a thing that’s currently a four, but could be something else later (while still being x)?

• Data vs. behavior: Do you work with simple data structures whose representation can be inspected, manipulated, and transformed? Or do you work with abstracted behaviors that do things, representing data only in terms of the things you can do with it, and let these behavioral abstractions operate on each other?

Most standard imperative languages lean toward using identity and data–pointers to C structs are about as purely this approach as possible. OOP languages tend to be defined largely by opting for behavior over data, often leaning toward identity as well but not consistently (cf. the popularity of “immutable” objects).

Functional programming usually leans more toward values rather than identity, while mixing data and behavior to various degrees.

There’s a lot more going on here as well but I think that’s the key part of what you’re wondering here.

---

If anyone’s curious I’ve elaborated a bit on some of this before: Analyzing some essential concepts of many OOP languages, more on the identity/value issue and also formal vs. informal approaches, a look at the data/behavior distinction in functional programming, probably others I can’t think of. Warning, I’m kind of long-winded, these are not for the faint of heart. 😛