
![✌️✨ A sketch of a cute gal sitting on a ledge, looking off at the empty page](https://padilla-media.s3.amazonaws.com/blog/art/flowygirlsketch.png)

It's been a while since I've shared something from the sketchbook!


Flowy Girl Sketch


From "The Listening Book" by W.A. Mathieu. Full title of the essay says it all: _There's Not Much to Learn and It Takes Forever_

> The truth is, a musician can spend a lifetime learning five notes and still not know everything in them. The more masterful you become, the deeper becomes the mystery and the more you are a beginner.
> 
> So when a student feels sluggish in learning a certain mode or cross rhythm, I have to say how there is hardly anything there to learn but that it takes more than one life.
> 
> ... there is no ought-to-know-how, there is only the uncovering of ourselves when we sit at the polishing stone.

It was in my Masters, after 15 years of playing, that I started to think I was getting the hang of things. Only to find out 5 years later that there's much, _much_ more to learn.

Copy and paste to your discipline of choice.

Mathieu on Learning Pace


I found myself in a situation where I had constructed a `ProcessState` class for storing the results of a cron job that runs on AWS. Passing the instance of `ProcessState` works just fine when it all happens in a single package. _But_ then I needed to store the state in our database temporarily while the lambda kicks over to another procedure within a step function.

I needed two things:

1. A succinct way to export the state.
2. A way to load the state from the db and re-instantiate my `ProcessState` class

Two built-in Python methods did the trick: the `__dict__` Special Attribute and the `@classmethod` decorator.

## Starting File

Here's `ProcessState`:

```
import logging
from logging import Logger
import datetime
from .types.unit_dict import UnitDict


class ProcessState:
    """
    Object for storing and formatting Process State
    """

    def __init__(
        self,
        result: list[UnitDict] = [],
        complete: bool = False,
        errors: list[str] = [],
    ):
        self.result = result
        self.complete = complete
        self.errors = errors
        self.logger = logging.getLogger("ProcessLogger")

    def __repr__(self):
        return f"ProcessState('{self.result}', {self.complete}, {self.errors}"
        
    # Methods for updating and formatting date here.

```

From the type hints, you'll see that we're dealing here with properties of basic types: lists and a boolean. I've also instantiated the class with a logger.

## Exporting with the Dict Attribute

If I want to get all of those properties, I can simply call the `__dict__` attribute directly:

```python
ps = ProcessState()

# Update the state here.

# Get the dictionary
dict = ps.__dict__
```

If I'm only storing values I want to pass along, this works great!

The wrinkle comes with the logger. I'm not interested in passing that along outside of my application. But the result will include reference to the logger.

So I'll have to handle filtering it out with a few helper functions:


```python
class ProcessState:
    """
    Object for storing and formatting Process State
    """
    
    ...

    def get_dict_from_state(self):
        result = {k: v for k, v in self.__dict__.items() if self._is_value_property(v)}
        result["created_at"] = datetime.datetime.now().isoformat()

        return result

    def _is_value_property(self, v):
        if isinstance(v, Logger):
            return False
        return True
```

I've also gone ahead and added a "created_at" property.

Now, calling `ps.get_dict_from_state()` would provide only the errors, complete state, and result. _Excellent!_

## Loading a Dictionary Into Our Class

Say I pass the result off to my DB. I then query the db for those values again. 

Looking at my `__init__` method above, I could _almost_ get away with passing in the dictionary as-is with a spread operator like so:

```
ps = ProcessState(**dict)
```

_However_, my `dict` now includes a `created_at` property which I haven't included in the `__init__` function!

If it were important to persist that field, I could add it to my init function. Or I could make use of an extra `**kwargs` at then end of my init signiture to catch any arguements not already defined.

_BUT_ say that I also need to do some data massaging, such as instantiating another class within `ProcessStates` own initialization?

`@classmethod` is the answer. 

I'll show how I'm using it, then how to construct it:

```python
ps = ProcessState.from_dict(dict)
```

very similar to calling the `__init__` method, though we're not tied to one signature. In fact, we could have multiple `@classmethods` for different scenarios, lending more flexibility to our instance construction.

The simplest way to implement thiswould be to pass everything in:

```
class ProcessState:
    """
    Object for storing and formatting Process State
    """
    
    . . . 
    
    @classmethod
    def from_dict(cls, values: dict) -> "CollectionState":
        return cls(**values)
```

However, as I mentioned, we have an unwanted attribute. Here I'll filter it out with list comprehension:

```
    @classmethod
    def from_dict(cls, values: dict) -> "CollectionState":
    	filtered values = [x for x in values if x in ["errors", "results", "complete"]] 
    	return cls(**values)
```

With that, we're back up and running, ready to use `ProcessState` in our function!


Passing State in Python with the Special Dictionary Attribute & the Classmethod decorator

Faber - Chocolate Blues


My first draft of this, I'll be honest, waxed poetic on time and identity. I wrote about my [Saturn Return](https://en.wikipedia.org/wiki/Saturn_return), the transient nature of reality, and how we are, in essence, a part of the universe observing itself.

_BUT THAT'S NO FUN!_

So instead, here's my listicle of **30 lessons learned** leading up to this big, hairy landmark.

# 30 Lessons

1. **Enthusiasm is the most important compass.** I think about this a lot when it comes to planning my own future. I have no idea what will make me happy tomorrow. And that's ok! There will always be something to be excited about and moving towards!

2. **Everything has diminishing returns at some point.** Money, networking connections, living in excess, even living a balanced life to a degree. Aim for 80% in most things, that's the sweet spot of effort and reward.

3. **Life happens in seasons.** If you're a high achieving type, it's easy to fall into the idea that production should always stay high. But we need those slow periods for reflection and recharging. A cliche at this point. But really feeling this on a month to month, year to year, decade to decade level has been powerful.

4. **Eat well.** Seriously.

5. **Sleep.** Another boring one, but come on! It's _really_ important! I can hear you now: "What's next, are you going to tell us to exercise?!"

6. **Exercise.** Get out of your head and into your body. A good walk is great medicine.

7. **It all works out in the end.** It's hard to know this without having a few lived experiences of genuine challenge under your belt. I feel like I'm _just_ getting there. But trust me. It all works out in the end. In every way, this too shall pass.

8. **Success is not a direct result of effort.** Don't get me wrong, effort is wildly important. But it's actually effort multiplied by a much, much, _much_ larger variable of luck, and a third variable of resources (eg "talent" or inclination). A big lesson late in my 20s has been to accept this and use it. Work steadily, stay humble, and look out for open opportunities. It's much more enjoyable than the brute force method.

9. **On n'arrive jamais.** One never arrives. (Quoting musicians here for you [Eugene Rousseau](http://stevestusek.com/forward-to-rousseau-biography) / [Marcel Mule](https://en.wikipedia.org/wiki/Marcel_Mule) fans!) The anticipation is greater (and really lots more fun!) than the realization. [Take time](https://open.spotify.com/track/3NXOn6Jurm7LXk8P2S3aBj)

10. **Keep in touch.** Doing this in an intentional, genuine routine is an easy way to get the ol' warm n fuzzies.

11. **Don't take anything too seriously.** _Seriously._

12. **Back up your files!!** I grew up having to reinstall windows on our home PC every couple of years. It wasn't a big deal when it was just kidpix files on there. But now that _all_ of my work is digital, it's a necessity.

13. **Make time for personal creative projects.** Even when what you do for work _is_ creative. This has been a lifeline for me. There are so many reasons for it. It's fun, you learn so much by doing it, you discover identity through it. And anything works! Blogging, Twitch streaming, fan fiction. Actually, Vonnegut says it best: _". . . Practice any art, music, singing, dancing, acting, drawing, painting, sculpting, poetry, fiction, essays, reportage, no matter how well or badly, not to get money and fame, but to experience becoming, to find out what's inside you, to make your soul grow."_

14. **Attention is the greatest gift to give and receive.** Paraphrasing from Simone Weil, as discovered on the blog formerly known as [Brain Pickings](https://www.themarginalian.org/2015/08/19/simone-weil-attention-gravity-and-grace/).

15. **Acceptance as a horizon.** Just starting on the path of learning this one. Probably the most important one on the list. Acceptance of others and self is wildly intertwined. Part of growing up is simultaneously being open to the differences in others and yourself. A tricky thing, too big for a listicle!

16. **Beware the differences between your genuine values and societal values.** Again, enthusiasm helps here in parsing which is which.

17. **There's greater wisdom in the gut than we give credit for.** Some of my better decisions were against reason and in favor of intuition.

18. **Be who you are now.** A lesson from teaching music to kids. Pardon the philosophical bent here: A 6th grader's purpose isn't to grow up or to learn all their scales for 7th grade. It's to be a 6th grader. We're all working towards something, but losing sight of who we are _now_ takes away from the unique joys of where we are. The best lessons I taught were ones where we savored enthusiasm. Particularly for beginners, savoring the newness of learning a song _they_ were inspired by. (Sometimes it was [Megalovania](https://www.youtube.com/watch?v=0FCvzsVlXpQ&ab_channel=TobyFox-Topic)...actually, most of the time it was Megalovania.) And yeah, then we did some scale work too.

19. **Do something for work, and something else for creativity's sake.** I'm here to say it's true, both halves make a greater whole. The nice thing is that the vehicle for money can be inspiring too — coding and music both support each other creatively for me.

20. **Books are great.** Go pick one up! Remember how CRAZY BONKERS it is that you and I are connecting minds _right now_ across TIIIIME AND SPAAAACE - through the **magic** of printed text!

21. **Invest in your tools.** When I started at UT, I was simultaneously playfully poked at for playing on awkward mouthpieces, _and_ I was praised for making them work. BUT after buying newer, nicer setups, it was just easier to sound good and more fun to play the dang horn!

22. **You don't need to be a gear-head.** Then again, I was learning to code on a $200 chromebook that I had to install linux onto. Build times took ages. But it got me here. 🤷‍♂️

23. **There's so much time.** Back to no. 18. Not so much a lesson as much as an observation. The 20s to me felt like a race to _Arrive_ and find stable ground. Once you have it, somewhere between 28 and 36 for most folks I talk to, the world opens up. So savor whichever stage you're in, the striving or the sustaining. Both have their own beauty on the journey.

24. **It's ok to give up on something partway through!** Thanks for reading! 👋


Chris Padilla/Blog

On This Day