
<figure className="reset">
	<video
	  autobuffer
	  loop
	  type="video/mp4"
	  playsInline
	  controls
	  className="full-width"
	>
	  <source
	    src="https://padilla-media.s3.amazonaws.com/blog/video/AmericanFootballHonsetlyCompressed.mov"
	    type="video/mp4"
	  />
	</video>
</figure>

_"Honestly I can't remember all my teenage feelings..."_

The angst continues!


American Football — Honestly?


![🦜](https://padilla-media.s3.amazonaws.com/blog/art/BirdBoxAnimationTransparent.gif)

Happy lil guy for an upcoming project!


Toucan


I've always been a journaler, but I made the move to do part of it digitally after reading [Derek Sivers' practice](https://sive.rs/dj) a few years ago.

If you dig in the coments, you'll see that Derek even uses the idea of linking, in a non technical way ("go see ThoughtsOn.txt for today"). [Obsidian](https://obsidian.md/) users with their backlinks may laugh, but part of the power is in how portable that statement is regardless of software

It's interesting to consider that the most impactful features of a computer are so basic. The ability to search a large volume of text quickly. To organize. And to store it all compactly. Everything else on top of that is sugar and risking tight-coupling to a vendor.


Plain Text Journal


![🦆🐤](https://padilla-media.s3.amazonaws.com/blog/art/sketches-2024-05-11.jpg)

In our neighborhood, we had a duck couple move into the community pool. Now their ducklings have hatched and they're one big, happy duck family!


Duck Fam


Of the core pillars of Object Oriented Programming, **Polymorphism** affords a great deal of flexibility. While inheritance allows for encapsulated and abstracted data to be shared, polymorphism allows for the redefining of both the data and the attached methods based on context. 

Java supports polymorphic behavior through two means: **Method Overloading** and ** Method Overriding**.

## Demonstration

Say that I have an `ArchiveItem` class that stores the basic details of a name and id. Here I'll demonstrate both overloading and overriding:


```Java
package polymorphism;

public class ArchiveItem {
	private String id;
	private String name;
	
	// Overloaded constructor with all instance variables supplied
	public ArchiveItem(String id, String name) {
		this.id = id;
		this.name = name;
	}

	// alternative constructor with only the name provided
	public ArchiveItem(String name) {
		this.name = name;
		this.id = IDPackage.generate();
	}

	// Override the base equals() method
	@Override
	public boolean equals(Object compared) {
		if (compared == this) return true;
		if (!(compared instanceof ArchiveItem)) return false;

		ArchiveItem comparedItem = (ArchiveItem) compared;

		return this.id.equals(comparedItem.id);
	}

	// Override the base toString() method
	@Override
	public String toString() {
		return String.format("%s: %s", this.id, this.name);
	}
}

```

Taking a look at my constructors, I'm overloading the `ArchiveItem` method by declaring the same method, but with a different number of arguments both times. When instantiated, Java will know which of the two methods to run based on what arguments are provided. Another way of putting it: One of the two methods will be called depending on their signature.

Looking further down, I've written an `equals` and a `toString` method. All Objects in Java come with these methods. Every class inherits from the base Java Object class, and on that class are implementations for `equals` and `toString`. In fact, `toString` is what's called anytime you print an object to the console.

Without any adjustments, passing an object to `System.out.println()` would return something like this:

```Java
ArchiveItem guitar = new ArchiveItem("Guitar");
System.out.print(guitar);
// "polymorphism.ArchiveItem@28d93b30"
```

The base print method will print the classname to the left of the `@` symbol and the location in memory to the right. Typically, we want something more descriptive representing our class instance.

In the example above, I'm pringint instead the provided id and name of the `ArchiveItem`

By adding the `@Override` annotation, I'm declaring that I'm intending to implement my own logic for the already inherited `toString` method. The `@Override` annotation is actually not necessary, but recommended. This will flag to the compiler to check that you're in fact overriding an existing method. Great for catching typos!

## Putting It All Together

```Java
ArchiveItem piano = new ArchiveItem("Piano");
System.out.print(piano);
// "Piano, 93nkf903f"
```

Here it is in action! The `ArchiveItem` is instantiated with only one argument, so it calls the matching method. One line down, I'm calling my implementation of `toString` by passing my piano object into the print method.

Here is the same class but with a different constructor signature:


```Java
ArchiveItem piano = new ArchiveItem("custom-id", "Piano");
System.out.print(piano);
// "Piano, custom-id"
```


Polymorphism in Java


In JavaScript, there's a bit of magic in arrays and objects. They have methods themselves like `myArray.toString()`, and they also have a special way of accessing entries through iterator selectors `myArray[2]`.

C# actually exposes this method of class design through iterators!

To get that functionality, we need a method on the class that uses the this keyword:

```
 public string this[string key]
{
    get
    {
        return _dict[key];
    }
    set
    {
        _dict[key] = value;
    }
}
```

Above, we'll assume `_dict` is of type `Dictionary`, a built in Class that functions just like a Python dictionary or JavaScript object.

I've typed the above iterator value with a string, but you could set is as an int and use a List just as well.

Here's what it looks like if we were to reproduce some of the functionality of a JavaScript object:

```
using System;
using System.Collections.Generic;
namespace HelloWorld7

public class Object
{
    private Dictionary<string, string> _dict = new Dictionary<string, string>();

    public Dictionary<string, string>.KeyCollection Keys()
    {
        return _dict.Keys;
    }

    public string this[string key]
    {
        get
        {
            return _dict[key];
        }
        set
        {
            _dict[key] = value;
        }
    }
}
```

An exception: we can't really expose keys as a static method like we would in JavaScript here. If `Keys()` is made static, we would also have to make the internal `_dict` public, which defeats the purpose of encapsulating it.

Once that's set, you can create an object instance and return keys like so:

```
class Program
{
    static void Main(string[] args)
    {
        var myObj = new Object();
        myObj["name"] = "Chris";
        myObj["city"] = "Dallas";
        myObj["pets"] = "Lucy";
        Dictionary<string, string>.KeyCollection keyColl = myObj.Keys();

        foreach (string key in keyColl)
        {
            Console.WriteLine(key);
        }
        // name
        // city
        // pets
    }
}
```


Iterators in C#


I've been listening to Rob Ingles's narration of the Lord of the Rings audiobook. What a treat!

The books are full of songs and rhyme. Ingles actually puts these to his own singing interpretation. A friend told me that Ingles actually got Tolkien's approval for his compositions!

<iframe src="https://www.youtube-nocookie.com/embed/5ALVnUwKNf0?modestbranding=1&showinfo=0&rel=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture;" allowfullscreen className="youtube_video"></iframe>

[Listen On Youtube](https://youtu.be/5ALVnUwKNf0)

There's such a sense for mood, style, and melody. Really delightful! He really captures the folk feeling to Sam's Rhyme of the Troll:

<iframe src="https://www.youtube-nocookie.com/embed/vbkosl8nq_g?modestbranding=1&showinfo=0&rel=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture;" allowfullscreen className="youtube_video"></iframe>

[Listen On Youtube](https://youtu.be/vbkosl8nq_g)

Tom Bombadil's is probably my favorite. So bouncy, like a woodland Santa Clause. Rob even contrasts the sections with timbre, range, and articulation!! **WOW!!**

<iframe src="https://www.youtube-nocookie.com/embed/njwy02laJs0?modestbranding=1&showinfo=0&rel=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture;" allowfullscreen className="youtube_video"></iframe>

[Listen On Youtube](https://youtu.be/njwy02laJs0)


Rob Ingles Singing Lord of the Rings


A friend of mine was admiring the honesty of a mutual composer friend in saying "I work by deadline. It's the only way I get things done."

After nearly a year of blogging and over a year of putting music out regularly, I tend to agree!

# Listening to Intuition

What's worked for me is the regular interval that's expected of anyone putting things out online. Monthly newsletters, weekly podcasts, daily blogs. Except for me, it's been music, words, and art.

Especially in the beginning, arbitrary deadlines are a great way to kickstart a new practice. Some of the benefits:

- Perfectionism goes out the window quickly when something just needs to get done
- When you can't lean on perfectionism and design, there's only room to follow intuition. A big plus in cultivating that!
- The rhythm helps with any creative process. Routine gets the gears turning for what to make next
- At the start, simply making it to the finish line is its own reward, regardless of how the music / blog / drawing turned out

# Building Identity

Regularly sharing online at an interval is also great for identity. James Clear writes nicely on this in [Atomic Habits](https://www.goodreads.com/book/show/40121378-atomic-habits). The gist being that we are what we regularly do. So to be a musician, you have to music regularly.

Doing it in public helps others recognize that as well. I've been so flattered by the folks that have said that they've really enjoyed my writing or that they bopped to an album during work. Cultural validation is part of that identity.

# The Balance

There's a spot to find between two points on a spectrum. On one end, there's the rigidity of creating just to reach a finish line at one end. On the other, there's so much play and exploration and purely following whatever idea comes that nothing ever gets finished.

Personally, my challenge at the moment is being on the rigid side! I'm used to life-long commitments here, I played the sax for 20 years. So a new part of the process for me is taking time to reevaluate what intervals are still serving me and which ones need to change.

In other words, keeping quiet deadlines also means knowing when to let some go.

An example for me: In 2022, I wanted to release an album a month. Great fun! Very proud! So far, I've done that for 17 months.

I've kept that going while also picking up other practices, though. And the excitement for learning, say, to draw, has outpaced wanting to put an album out just because I said I would. And, of course, there are only so many hours in the day. So I'm at a spot where that needs negotiating.

No wrong answers, but taking the time to be intentional is what matters.

Like anything else in the actual creative practice — the structure around it requires both the lightness of play and a bit of detail orientation. When enthusiasm and play drives the decision, then the supporting choices can match effortlessly.


Deadlines as a Creative Tool


The stack is growing!

![Another one down 💪](https://padilla-media.s3.amazonaws.com/blog/art/sketches-2023-05-07-3.jpg)

This one was filled with more studies as part of the [Proko courses I'm taking](https://www.proko.com/).

![These boots were made for drawin'](https://padilla-media.s3.amazonaws.com/blog/art/sketches-2023-05-07.jpg)

Lots of bean studies as part of the figure drawing course:

![Rowin Atkinson everywhere](https://padilla-media.s3.amazonaws.com/blog/art/sketches-2023-05-07-4.jpg)

On to the next one!

![Jazz!](https://padilla-media.s3.amazonaws.com/blog/art/sketches-2023-05-07-2.jpg)


Chris Padilla/Blog

On This Day