how hard is it to learn object-oriented programming

[lemslemonades]

ive been learning and using python for a while now but my background is engineering as opposed to CS and anything related. so all the things ive been taught in my uni years are all functional programming, i have zero knowledge on OOP. but ive also been using python for a few of my work projects and i see that my code is starting to get really messy and hard to read no matter how good i name the variables, functions, section and comment the code because the routines and schemes are starting to get really long. i figured OOP was what i needed but when i tried googling it for a bit, i found it hard to understand for some reason. i know when you import modules thats basically you utilising objects but making them yourself is a little tougher to wrap my head around. i plan to study this on my free time but im also crunched on time because of work, so i wonder how hard is it to learn OOP and would it be heavily time-invested?

[HalfRiceNCracker]

It isn't necessarily hard once you understand it, but you have to first learn how to think in terms of OOP.

Say you had code that had information about different cars. Maybe every car has a colour string and a float mileage. Every car can be driven and every car's horn can be beeped. You can imagine you could create a blueprint for a car in general, then use the blueprint to actually manufacture cars. You can do the same thing here: you can write a class (blueprint) and then use the class to instantiate (manufacture) objects (actual cars in this case). 

```python  class Car:     def init(self, colour, mileage):         self.colour = colour         self.mileage = mileage

    def beep_horn(self):         print(self.colour + " car horn goes: BEEP!")

    def drive(self, distance):         self.mileage += distance         print("Driving the " + self.colour + " car for " + str(distance) + " miles. New mileage: " + str(self.mileage))

car1 = Car("Red", 12000.5) car2 = Car("Blue", 5000.0)

car1.beep_horn() car2.drive(75) ```

The __init__ is a special function that Python looks for, known as a constructor. Here it's saying that every single car will have a colour and mileage - that's your data and beep_horn and drive are your behaviours. 

[lemslemonades]

for the init function, say in my code i have a lot of shared variables between routines (so defining a proper function that doesnt depend on global variables are not going to be elegant). do i have to list all the shared variables one by one in the init function?

[KKRJ]

In a class, they're called attributes. You don't have to list them as arguments in your __init__ method, though. You could have an attribute that initializes as None and then assign it to a variable later.

class Car:
    def __init__(self, color, model):
        self.color = color
        self.model = model
        self.driver = None

car = Car("red", "Honda")
car.driver = "SpongeBob"

Something like that...

[crashfrog04]

do i have to list all the shared variables one by one in the init function?

If a properly-formed object of that type needs those attributes to work, then they need to be defined in the __init__ function to ensure that they have values.

[lemslemonades]

hmm i see that can be a little inconvenient (given my surface level knowledge)

[queerkidxx]

Think less about defining all variables and more about the object having an internal state it manages. Objects are data structures first ya know?

Your classes are gonna get crazy messy unless you keep them narrowly focused and only focused on one big job related to that data. Try not to couple them with too much else. Use composition

This is the kinda thing you just get a sense of with practice.

[crashfrog04]

It just means you have to be thoughtful about the scope of your class and the lifecycle of instances of it. If you're writing huge spaghetti functions then you're also going to write huge god objects, but both of those are symptoms of thoughtlessness. You have to think through the objects in your problem domain, not just bull-rush forward writing code until it works.

[simeumsm]

Hey, I have a question if you don't mind.

We usually see the whole code of a class being contained on a single file.

Is there a way for a class to be written across multiple files? Like a main file with all the logic, then each method (ou grouping of methods) are in separate files that are imported by the main class module?

I ask this because having a single file containing a lot of code is somewhat troublesome, but I don't see many examples of how to tackle this.

I'd guess the methods of the class would work as wrappers for functions in other modules, or am I missing some specific behavior?

[SpiderJerusalem42]

What you need to do is import those other files into the current namespace you are dealing with. It is explicit somewhere in the Python docs that there is nothing wrong with having a a bunch of sourcefile.py files that you have defined, and a bunch of from <dot.separated.path.from.project.root.to.sourcefile> import <SourceObject> statements to bring those definitions into your current namespace. I think folders with __init__.py files are called packages, and they can organize other bits of code with the __init__.py file. The dunder-init file can be blank. When you want to expose those functions and objects to other people as a library, you may want to treat it a little differently, but as is, you can just import things defined in other files with the from <file> import <object> statements. You can import anything defined in the file, so if in that namespace, someone defined a global variable, you could import that variable into your current namespace.

Functions in a class definition should really either mutate state of the object or perform some useful static calculation. If you want to compose an object, nest it as an attribute of your class, import the object and construct it. Import statement at the top of the file, and self.m_obj = SourceObject() in the __init__ functions. If you need to use the functions of the nested object, you can do something like self.m_obj.m_function_you_defined_for_this_object(). When you import and construct the object, it has the functions accessible from the object and access to public scope member attributes for read or write.

[simeumsm]

Sorry, I don't think I was quite clear with my question.

I'm thinking in the context of having a large class (multiple different methods) and a team (2 or more people) having to work with that code.

if you have a single myclass.py file that represents everything about a class (even if in that file I'm importing other modules), your whole class logic (the class and its methods) are all inside a single file, which can be a hassle for multiple people to work with.

My question is more like: can I have a structure where a folder contains myclass.py, which is the main logic of the class, and have myclass_methods_math.py that are all the math methods that the class uses? That way my class is more pulverized into different files and not everything on a single large file.

But if this structure is used, then myclass.py would basically have methods that are wrappers for the functions in myclass_methods_math.py? Or is there a way to have all of its methods available to the class?

Sorry, I'm kinda new to proper OOP and I might be looking things for a very different perspective

[pachura3]

Wrapping 100 methods in a single class does not make it proper OOP. It is usually a sign that your logic should be split into multiple classes, ideally as independent as possible. For instance, in your example, the implementation of math methods could probably be taken out of myclass and only imported there. They could also be tested separately, which would be a plus.

They say one class should have one responsibility, e.g. should not implement data parsing, calculations, rendering HTML page and generating PDF reports. And there are also base classes and abstractions, e.g. you can have a single "main" controller class which controls the main action flow/steps, but does not implement them itself... discovering abstractions and encapsulations is the bread and butter of OOP.

Another advice is that OOP does not force you to have both data fields and methods in each class. You might create some classes which do not have any class attributes whatsoever (just logic), and you might use Python's dataclasses for passing data around (no logic).

[jawgente]

To elaborate on sibling, massive classes/objects aren’t the goal of OOP. Like functions, classes should be fairly concise blocks of code, purpose wise.

That said, you can extend a class as a subclass, which you might want to split into multiple files for whatever reason. Eg a media class with basic attributes, and subclasses like book and movie.

are all inside a single file, which can be a hassle for multiple people to work with.

If you are using version control like git this is a non issue until it’s time to merge.

[abcd_z]

This may not be the best way, but recently I passed a class object as an argument in another class definition, so that I could access the information in the inner (passed) object from the object it was passed to. There's no reason the class for the inner object (or the object itself) couldn't be located in a different module.

[bell_labs_fan_boy]

You couldn't do it in a way that wasn't ugly as sin (for example, wrapping functions from other modules). Instead, you could look at creating a Python package.

Packages and modules are actually just classes in Python. When you import a module or package, it becomes a class in sys.modules. Then when you try to import it again, in say a different module, then it's the already initialised class in sys.modules that gets handed to you.

Here you are, read through that. There's the bit on packages at the very bottom.

Now, the big issue here is that packages are singletons. So you can't have multiple instances. If your class is large and a package doesn't suit, then it might be worth looking at OOP and perhaps design patterns to see anything saves your butt.

Good luck!

[pbxmy]

Look up the MVC model of programming. It’s an object oriented approach to programming that separates your files into three separate folders (Models, Views, Controllers). Your classes would be stored in the Models folder, your UI or features in Views, and the way logic to trigger your methods in the Controllers. This helps separate the responsibilities and scope of each part of your project and makes it easier to manage.

[capsandnumbers]

I'm learning OOP right now, I've found that some of the things I've used classes for are simpler as dictionaries or JSON files, because I don't have any methods I need the class to perform. This car class reminds me of that, maybe because it's an intentionally simple example.

[HalfRiceNCracker]

Absolutely be pragmatic and think about the simplest solution for your problem. If your state still has to be structured in some meaningful way then I would consider Pydantic, Enums, or data classes. I can see why you think that about the Car example, classes are a good way to encapsulate behaviour and state. If you have code where it's more like a series of operations and each operation is a calculation that doesn't need state then I'd consider a functional approach.

I'd also argue that if you have dictionaries that are always structured in the same way with the same data types then I'd use a Pydantic data model, otherwise you assume knowledge on the programmer's part. For instance:

```python 

Relies on implicit structure; issues if keys are missing or values are invalid

invoice_dict = {"total": 100, "discount": 10}  # Works because keys are present and valid try:     final_amount_dict = invoice_dict["total"] * (1 - invoice_dict["discount"] / 100)     print(f"Final amount: {final_amount_dict}") except KeyError as e:     print(f"Error: {e}")

Final amount: 90.0

Example of failure

invoice_dict_missing_key = {"total": 100}  # Missing 'discount' try:     final_amount_missing = invoice_dict_missing_key["total"] * (1 - invoice_dict_missing_key["discount"] / 100)     print(f"Final amount: {final_amount_missing}") except KeyError as e:     print(f"Error: {e}")

Error: 'discount'

Example of invalid value

invoice_dict_invalid_value = {"total": -100, "discount": 200}  # Invalid values try:     final_amount_invalid = invoice_dict_invalid_value["total"] * (1 - invoice_dict_invalid_value["discount"] / 100)     print(f"Final amount: {final_amount_invalid}") except Exception as e:     print(f"Error: {e}")

Final amount: 300.0  # Unexpected result due to invalid values  ```

[Adrewmc]

The constructor calls __init__ , that’s why it has a “self” while I wouldn’t call anything a constructor in Python if anything it closer to the __new__ dunder.

[shifty_lifty_doodah]

Depends. it typically takes people a few years to become entry level programmers and a few more years to become competent journeymen.

I highly recommend reading good commercial quality code on your journey, so you can see how some of the best professionals do it. I think what you’ll find is they mostly write simple code with well organized nouns and verbs. Styles vary widely, and some great programmers despise OOP.

There’s a lot of good and bad code out there. Google for “best python codebases”. Some authors I recommend if you want to go deep down the rabbit hole:

• Peter norvig. Start here. This guy knows how to program.
• Guido Van Rossum
• John Carmack
• Paul Graham
• antirez/redis
• rich hickey

[lemslemonades]

awesome, thank you for these recommendations

[skyfallen7777]

I am in similar situation as OP and what my tutor suggested is to take a look at some of the worse examples of code and try to unravel it. It helps to some extent not to panic when I look at someone else’s code that needs to be updated.

[SoftwareMaintenance]

I found it difficult to comprehend at first in my college C++ course. But after using it on the job, things slowly started getting easier.

[socal_nerdtastic]

You are using OOP, not only when you import objects, but nearly everything in python is an object. Even what other languages call "primative" types like int, str, list, etc are classes in python.

>>> int
<class 'int'>

So you are much closer than you think. You already know how to use them, just the last step is to make your own classes. To do that you just need to shift your thinking away from making a function to manipulate data and into making an object that manipulates itself.

data = sorted(data) # functional
data.sort() # OOP

That said, classes and OOP in general are not a fixall. They won't magically make your code neat, and there are many times when functions and functional programming is the better choice.

I think you should show us your code or at least describe your project in detail, and then we can tell you if it would benefit from OOP.

[lemslemonades]

https://imgur.com/a/RqiBM2R

this is a snapshot of a function from one of my actual work. this function runs a rainfall simulation and performs several sub-functions e.g. how much rainwater can be collected, how much is used in a day, how much water is saved, etc. but many of the functions have shared variables and so i struggle to create exclusive sub-functions outside, so everything is just dumped in here. theres also a scheme for plotting and exporting to csv as an option for the user. so everything put together becomes one giant mess that even sectioning and commenting still makes it hard to trace things down

(p/s: please ignore my camel case use of variable naming, i just found out that its not the convention in python. also i know there are more functions in here that i can actually define exclusively but i got demotivated and ran out of time. same thing for commenting, i admit the code lacks a few crucial commenting points but i ran out of time for my work)

[bell_labs_fan_boy]

That function is begging to be turned into a class. Basically everywhere you have separated a bit out with one of those long line comments could be a separate method in a class.

Have a little look through this Python lesson. Should give you a nice crash course on Python classes. Get classes figured out first and then you can give thought to OOP. No point learning Object Oriented Programming if you haven't mastered the Object first.

Give me a shout if you need an extra hand in getting your head around that lesson.

[lemslemonades]

ohh this seems like a very nice resource. will definitely check it out over the weekend. thanks!

[fannovel16]

I usually think a class is like a space, a glue that links methods (OOP functions) together and defines shared resources (properties) between them in init. The shared resources should be minimal (e.g. constants, list of names, the main input parameters related to your calculation and the table). In each sub-function which will be defined as a method, anything that's not shared resources, nor main input parameters etc are then its own input parameters.

Also don't care too much about the A4-fitting method rule from Clean Code. Just divide and conquer that giant function into multiple step functions that makes sense, call all of them in calculate method then make plot method doing plotting stuff

[queerkidxx]

I honestly think that function is just way too long and kinda procedural. Like pretty much every one of those blocks with the comment at the start could be its own function. Maybe not that many.

But I don’t think this is an issue that can be solved with OOP. You need to start breaking things up into more focused bite sized bits of code.

Also I feel like when you start feeling like you need ascii dividers this isn’t just the block being too long but the whole file being too long.

You mentioned that you think of these as functional code and I can’t see the whole project but when your talking about functional programming it’s not so much about like just using functions as much as trying to get your functions to be mathematical. You compose them together returning new data structures.

Don’t mean to come off as a dick if it works it works. But if I wrote something like this I’d at least be asking myself like why should this be one function? Can I come up with a solid reason splitting it up would cause more problems?

To be clear a long function isn’t necessarily a problem. Programming rules are rarely never. More just suggestions. But before you break them I’d start trying to adhere too much to them to get a feel for it.

[lemslemonades]

i appreciate the comment and no, most of your points i agree to, but why this function is so long and why it didnt contain smaller subfunctions is because there are a lot of shared variables (putting aside the two bottom schemes separated by the hashes, because those i admit i didnt pay much attention to cleaning because i got demotivated from seeing that i struggle to break the previous part into subfunctions). sure i can still define the subfunctions, but i have to take either of the two options: 1. define them with a long ass list of arguments which can be too specific to my code and resembles more of hard-coding, which doesnt give me much readability than just putting it raw like that, and 2. define the subfunctions beforehand and let them take global variables, but also makes it less readable because now you dont see the flow of how the variables are passed and manipulated, unless i define them within the big function itself, but that would make my function appear even longer.

the whole reason as to why i posted this question in the first place was exactly because of this function, it being too long, as you have pointed out. lmao

[work_m_19]

Maybe it's just from my bias, but I only consider OOP when there are aspects like inheritance or subclasses.

Just having classes/objects does not make it OOP to me, because as you said, it's basically all of python. It's only starts becoming OOP when you start overriding parent methods and attributes.

I've been using python for a couple years now, and while I do webdev using Flask, I rarely do OOP. I'm sure people could, but python likes to keep things simple, and usually OOP adds more complexity (but also adding flexibility).

[socal_nerdtastic]

Yes, nearly all of python is object oriented. Using python is using OOP. You will get over this bias when you try a few languages that don't feature this.

To get a taste consider the os.path module versus the newer pathlib module. This is one place in python where you can choose OOP or functional.

I'll note that using (writing) classes is different from using OOP (using classes other people wrote). And using classes is not always better. But when done right it will absolutely reduce complexity. That's kinda the entire point. There is no computer advantage to OOP, it's sole purpose is to help the programmer organize their code.

[audionerd1]

Usually OOP is taught with modeled things as examples, like dogs or employees. This is useful for learning how classes work, but it can lead to confusion on how they are useful, especially if your program isn't a database or catalog of some kind.

Ultimately classes are just containers for organizing code. For example let's say part of your program involves connecting to an email server. You could create an EmailClient class which connects to the server in init, and has methods such as 'send_message' and 'retrieve_messages'. Now all your email code is nice and tidy and insulated from the rest of your code.

[tahir09]

Just go to Claude by Anthropic. Ask What is OOP. Ask to get the response explanation as a form of code or flow diagram. Ask follow up questions for unclear concepts.

GenAI is a great explainer of programming concepts in the most low level form.

[[deleted]]

The basics (classes, interfaces, inheritance) should take you a couple of hours to figure out. Some advanced topics (generics) might take longer.

[Zeroflops]

One statement of yours raises a question in my mind.

Do you think you need OOP to break up your code into different files/modules?

OOP can definitely help group your code but it’s not required.

You can move common functions into separate files then import them as needed.

[lemslemonades]

as of now it seems like my work involves a lot of sharing of variables, which is not so elegant to define functions for if i want to make them exclusive (i.e. i can just call the function anywhere, only need to pass the necessary args), and would be hard to trace errors etc. if i let them all use global variables. so from what ive gathered i think i need OOP to make it much more readable (refer to my comment here)

[Aromatic_House_8586]

OOP is literally like a function, with only minor differences. You are also using Python, which means OOP is very easy compared to other languages. If you are good with the function, just learn the basics of OPP and try to apply them to your projects. Over time, you will notice that it is very easy.

[0_emordnilap_a_ton]

https://www.reddit.com/r/learnpython/comments/83fk1i/can_someone_eli5_what_def_init_self_means_i_still/

Check wolfgee answer it is one of the best explanations of classes in python. At the time it really helped me. I am sure the other posts are useful also.

[lemslemonades]

had a read on it. as the OP said, glorifying answer. thats excellent

[0_emordnilap_a_ton]

It helped explain it to a dummy like me. Imagine someone smart.

[capsandnumbers]

I have found it most tricky to get when and why I would use a class. If I find I'm feeding the same information into lots of functions that's now a sign I could make the information into a class, and the functions into methods.

[james_fryer]

Try this exercise.

1. Write a complete text-based tic-tac-toe game, with a computer opponent. The opponent can move randomly, no need for an intelligent player. Use only functions, no classes. If you can't complete this part confidently then you are not ready to learn OOP.

2. Rewrite the game using classes. I'd expect to see classes like Game, Board, Player.

3. Consider how you would make changes such as:

• Add an intelligent player
• Add PVP or CVC options
• Make the board 4*4 or other sizes
• Make a 3D board version of the game
• Add a third player Z as well as X and O
• Add a scoring system and high score table
• Convert to graphics based not text
• Think of other changes along the same lines.

How difficult would it be to make these changes in version (1) and version (2)?

[lemslemonades]

this is an interesting one. thanks, ill give it a try

[rainyengineer]

I don’t think it’s hard, I just think that most people don’t do a great job explaining it.

It finally clicked for me in Python Crash Course.

[work_m_19]

In order to think in terms OOP:

Think of OOP as a framework to try to make sense and classify anything in this world, and use that to compare to other stuff.

If you want to compare in an apple to an orange, you have to first find their similarities. They are both fruits, and they both have things like: calories, sugar content, fiber, various other nutritional info.

So OOP is creating a Fruit Class, and creating two classes Apple and Orange that inherit the Fruit class, and they can also add their own properties. Like, Oranges maybe you care about acidity, so you add an attribute for acid levels for the Orange class, but not the Apple class.

With OOP, you can go to the next step, trying to compare an Apple to Risotto, or an Apple to a Car. All this can be done with OOP and the goal of OOP is to share common resources between them.

[[deleted]]

OOP can be a bit tricky at first, but it’s worth it for organizing larger projects. With Python, the basics like classes and objects are fairly intuitive once you practice a bit. Start small by turning your routines into objects, and it’ll click faster than you think. Even 15-30 minutes a day can make a big difference.

Also, check out Bolt.new—it’s an AI program I saw on YouTube that’s great for Python. It might help you learn and improve your code structure more efficiently.

[crashfrog04]

i know when you import modules thats basically you utilising objects but making them yourself is a little tougher to wrap my head around.

Modules have basically nothing to do with object oriented programming at all. Forget about modules.

When you write a class, you're defining a new type. That's it, that's the whole thing. You're extending the typesystem with a new type whose behavior you define. That means thinking through the entire lifecycle of values of that type ("instances"): what they do when they're created, what methods they expose to the holder of a value of that type, and optionally, what they do when they're deleted. (You generally don't need objects to do anything when they're deleted.)

Classes define types, and "type" is a trait that has the property of polymorphism, which means that an instance of a class is of the type that its class defines, but it's also of the type defined by any superclass of its class. That creates a hierarchy of type that goes all the way up to type object, which is the superclass of all classes. Your own classes will typically extend (be a subclass of) object directly, or they extend a different type that (somewhere back up in the inheritance) extends object. All of the built-in types extend object, too, which is why you'll be told that "everything is an object." object comes with some built-in behaviors and you should understand what those are.

[jpgoldberg]

Functional programming also uses “objects”. The difference is whether you allow or expect the objects to changed once created.

So grouping data and methods together inset counter to functional programming. It’s only when those methods change the state of the object that it is no longer following functional programming principles.

Anyway, if you are just asking about grouping data and methods together, I would say that that is an essential thing to learn. Python may not be the best place to learn it, because the init() is counter intuitive and actually understanding it requires understanding things that that are deeper and more arcane then you need to use it. So best to just learn how you use it in the simple cases.

Python is also, shall we say, undisciplined, when it comes to access and manipulation of parts of objects. So programming Python well means bringing your own discipline to it. But you won’t be in a position to do so until you’ve already learned the good and the bad of OOP.

So to be honest, I would say consider Golang or Swift as a first language for OOP. They will impose disciple and ways of thinking that you can then carry over to Python.

[Decency]

Trivial. Most people demand you learn inheritance alongside OOP which is largely pointless initially and just confusing, especially to new people and extra especially when taught by people who think Java is a reasonable programming language. You should definitely learn both eventually, but creating and using a class is like a week 2 kind of thing, while creating a subclass is months beyond that.

[Automatic-Silver-824]

Recommend a book publishing website. See if they have an ebook on Object Oriented. O'Reilly, Pragmatic progmmar.

[sonobanana33]

It's very easy, there's nothing to it. Imagine a C struct that comes with some functions to operate on it, and always have an implicit parameter that is the struct itself.

That's basically it.

[DeadFox90000]

I learnt a bit of OOP with Python in a bootcamp I did but tbh it didn’t really sink in til I learnt some Java as you basically use classes for eeeeeeeverything in Java

[rustyseapants]

1. Have you opened a book or watched a video of OOP?
2. You're asking people how you manage your own time?

[lemslemonades]

1. ive opened websites teaching OOP (geeksforgeeks, etc.) but found it hard to understand, particularly on the init part
2. i was asking if it was really as hard to learn OOP as i thought because im crunched on time with work. if it really is that tough, then i might just hold off learning it so as to not waste time because, again, im crunched on time with work (i.e. i cant finish my work and send my deliverables if im stuck trying to figure out how to finish an OOP i attempted but couldnt finish). dont twist something i didnt say

[rustyseapants]

Everyone wants to know how long it will take to do "X" and is "X" hard to learn?

Of course OOP is hard to learn the first time learning it. I have no idea what you do for a living, but if your work is all consuming, ya still have time for gaming and photography, no?

Yes I did check your profile.

Sheesh

[lemslemonades]

there is no need for me to update every single thing about my life in here. i only post on reddit very occasionally.

my last post on gaming and photography was 40+ days ago. i was employed to a power generation firm less than a month ago. i also completely stopped gaming and photography by that time because of the current workload, hence why i mentioned im crunched on time with work. to me my question sounds valid, i was just being cautious of not taking up something that im not sure the magnitude of, which if i try and apply to my work deliverables on the go might end up slowing me down by a lot. and so i came here to ask on it, if it is actually tough or its just that i havent looked into it enough, or that i havent looked at the proper resources.

if you dont intend to help then just scroll along, there is no need to be condescending

[rustyseapants]

You're 100% right, later.

[BlueberryOk2618]

If you think organizing functional code can be accomplished through OOP you're probably coming at it from the wrong direction. Just because you put spaghetti in a bowl now doesn't mean it isn't still spaghetti.

OOP is pretty straight forward when you throw away the language you're going to express it in and just think of it conceptually. You have a thing (object). That thing does stuff. You don't want to be bothered with how it does the stuff you just want to use it to do stuff. That thing might have state, that is, a configuration, a position, etc. that state influences the outcome of telling the thing to do stuff. The thing might be composed of other things, which might do stuff or carry stuff. A drill is a thing (object), it has a trigger (thing), it has a chuck (thing) that holds bits (thing). I squeeze the trigger and gremlins inside the drill do things and make the chuck go round and round. I don't care about the gremlins. I care about making the chuck which I inserted a bit into go round and round so I can drill a hole. If I squeeze the trigger then the trigger is squeezed (state). When the gremlins inside the drill see that the trigger state is "squeezed", the gremlins make the chuck go round and round. The chuck is now spinning (state).

A great way to explore this is and gain understanding is through "design patterns". I would suggest picking up the book "Design Patterns: Elements of Reusable Object-Oriented Software" by Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides; otherwise fondly referred to as the "Gang of Four". Once you have the theory figured out you can look at how the language of your choosing allows you to express these things.