diff --git a/content/thoughts/the-types-of-oop.md b/content/thoughts/the-types-of-oop.md new file mode 100644 index 0000000..4874d34 --- /dev/null +++ b/content/thoughts/the-types-of-oop.md @@ -0,0 +1,105 @@ ++++ +title = "The Types of OOP" +date = 2022-05-31 +draft = true + +[taxonomies] +tags = ["programming", "oo"] ++++ + +I'm seeing that a large group of newcomers don't get the idea behind object +oriented programming. And I think this misunderstanding is basically the way +this is explained. + + + +If we take a page from the classical "first look" at OOP, we would see something +like + +```python +class Animal: + def say(self): + print("Don't know what to say") + +class Dog(Animal): + def say(self): + print("Woof!") +``` + +The example usually creates a base class, with a method (function), extends the +base class in a child class and overrides the method. And that's basically it. + +But, in real life, things are not quite like that. + +Ok ok, there are examples in real life that are basically that, but I don't +think we *start* with that, we *use* that. + +So, what do I mean by "Types of OOP"? + +## The Grouping + +One of the types of OOP we usually do is "grouping". What do I mean by that is +that we usually have a group of values that are related and should be worked +together. + +For example, in stock markets, we have the concept of a "candle": The candle +summazes what happened in a period of time -- be it one day, one hour, one +minute of 10 milliseconds. In that space of time, we capture the first value +seen, the last value, the highest value and the lowest value. We could, for +example, use a series of arrays for that, like + +```python +first_values = [10, 20, 14, 21, 17] +last_values = [20, 14, 21, 17, 12] +high_values = [30, 20, 21, 21, 18] +low_values = [9 , 14, 13, 17, 12] +``` + +Here, each "column" represents one entry in the period time; if we are doing it +per hour, that means in the first collected hour we have the values in the first +column, one hour later we have the values in the second column and so on. Thing +is, those values are related, and we could basically group them together. + +```python +class Candle: + def __init__(self, first, last, high, low): + self.first = first + self.last = last + self.high = high + self.low = low + +entries = [ + Candle(10, 20, 30, 9), + Candle(20, 14, 20, 14), + Candle(14, 21, 21, 13), + Candle(21, 17, 21, 17), + Candle(17, 12, 18, 21), +] +``` + +This is basically the same thing, but now instead of having multiple arrays, we +have just one that keeps all related information together. The concept of +grouping information like that is not something new and even C had a `struct` to +keep related values together. But when we use objects, we can also add +"behaviours" to our data, and we could ask if the candle is going up or down, if +that would help us in our requirements. + +A simple example could be the name of a person + +``` +class Name: + def __init__(self, first_name, last_name): + self.first_name = first_name + self.last_name = last_name + + def full_name(self): + return "{} {}".format(self.first_name, self.last_name) +``` + +For a person, we have related information like the first name and last name. But +if we want to put their names in an envelope, we need to print both names +together, so we added a "behaviour" (method) to produce that for us. + +Quite simple. + +## The Façade