← Back to context

Comment by vips7L

5 days ago

Object orientism is just encapsulation. It’s the only thing that is required. You can have objects without inheritance and virtual dispatch.

11 comments

vips7L

Reply
bccdee  4 days ago

Languages like Go and Rust have module-scoped visibility, though. This is definitely encapsulation, but I wouldn't call it inherently OO.

vbezhenar  4 days ago

So Python is not OOP language? You can't hide fields.

  • nr378  4 days ago

    You can hide fields in Python with a little bit of gymnastics:

      class EncapsulatedCounter:
      def __init__(self, initial_value):
          _count = initial_value

          def increment():
              nonlocal _count
              _count += 1
              return _count

          self.increment = increment


  counter = EncapsulatedCounter(100)
  new_value = counter.increment()
  print(f"New value is: {new_value}")

    • d0mine  4 days ago

      Usually, a simple function is enough:

          def make_counter(start=0):
      count = start
      def incr():
        nonlocal count
        count += 1
        return count
      return incr

      Example:

          >>> c = make_counter()
    >>> c()
    1
    >>> c()
    2

      But it hides nothing:

          >>> c.__closure__[0].cell_contents
    2
    >>> c.__closure__[0].cell_contents = -1
    >>> c()
    0

      "private" in Python is cultural, not enforced. (you can access `self.__private` from outside too if you want).

taberiand  4 days ago

I would say specifically encapsulation of mutable data

  • vips7L  4 days ago

    Lots of modern OO uses immutable data.

    • bccdee  4 days ago

      A lot of the underlying intuition behind OOP is expressed as "cells exchanging messages like an organism" and such, and I think that implies the distribution of state among a variety of small, special-purpose state-managers. More functional variants of OOP where state is managed centrally are a meaningful shift away from traditional ideas of OOP, and I think calling them both equally OO glosses over that shift a little.

    • taberiand  4 days ago

      What's a good example? What comes to my mind is modern C# which I would say is a multi-paradigm language that encourages things like immutable records and interfaces and composition over inheritance as alternatives to the now less favoured OOP styles that it also supports