Bird Box Track


![❄️🐇](https://padilla-media.s3.amazonaws.com/blog/art/sketches-2025-03-15.jpg)

We have tons of rabbits hopping around in our new neighborhood! Love these little guys.


Winter Bun


Something that took me a few decades to learn about playing music is that there's no one way to do it. There's also no one reason to do it.

On one end of the spectrum, music can have this perception of being something that "comes from the heart". Images of La Bohème come to mind, the artist that wears their emotions on their sleeves, the ever-romantic. They play what they feel. And yes, that's a part of musicing. I even quite like that part of it! But that's not the only part.

On another end, you can imagine a discipline-driven approach to music. Think child prodigies, the movie [Whiplash](https://www.imdb.com/title/tt2582802/), or any experience you may have had as a school band student where the aim was to ace your state marching contest. There are some benefits to this approach to music for some people. Personalities with that competitive spirit and skill-acquisition-for-the-sake-of-skill-acquisition can lead with this. I'll admit to having spent a great deal of time driven this way.

Here's one that sits neatly in the middle of the two: music as a puzzle.

Pick your favorite analogy: sudoku, crosswords, knitting, solitaire, wordle. Mine is [Pushmo](https://en.wikipedia.org/wiki/Pushmo): A Nintendo handheld game where you play as a little guy trying to solve spacial puzzles to reach the top of a structure. The pieces are often shaped like cute Mario characters.

I got to thinking about this while watching my mom work on Jigsaw puzzles during a visit. After I had practiced piano, I started to notice similarities:

- There's a set of rules that requires more than purely logical reasoning. It's often spatial or even economy of movement.
- It's low intensity. Many of us spend our days on problems that require loads of thinking. These are typically great compliments since they keep us moving intellectually, but with a different part of the brain.
- It's often [repetitive](/repetitionandmeditation). One puzzle piece after another. One measure at a time.
- It's cozy. Great to do in the evenings before bed.
- The end result is something beautiful or satisfying, though most of the enjoyment comes from working out the solution, not having it.

I like highlighting this because it takes the pressure off of playing an instrument — needing it to be for some grand purpose. You can simply enjoy doing it!

I see too much advice either in the vein of "_You show up in the practice room whether you feel like it or not!_" or "_Just follow your heart!_" The truth is, sometimes I truly don't feel like it, and sometimes my heart is not particularly jazzed about anything on a given day.

But I am regularly curious about solving that puzzle of sound, motion, and phrasing.


Music as Puzzles


Both [React Native](https://reactnative.dev/docs/getting-started) and [Expo](https://docs.expo.dev/tutorial/create-your-first-app/) have great quick start guides for getting your hands dirty.

If you're _really_ in a rush to see what developing with React Native looks like, I've boiled it all down to one file for you!

```
import React, { useEffect, useState } from 'react';
import { View, Button, StyleSheet, Platform } from 'react-native';
import { Audio } from 'expo-av';
import { Sound } from 'expo-av/build/Audio';

type SampleComponentProps = {
  soundSource: any; // an MP3 File
};

export default function SampleComponent({ soundSource }: SampleComponentProps) {
  // React hooks work as expected
  const [sound, setSound] = useState<Sound>();

  useEffect(() => {
    const loadSound = async () => {
      // Handle mobile device interactions with expo libraries
      const { sound } = await Audio.Sound.createAsync(soundSource);
      setSound(sound);
    };
    loadSound();
  }, [soundSource]);

  async function playSound() {
    if (sound) {
      // Run certain logic on specific platforms
      if (Platform.OS === 'ios') {
        await sound.setPositionAsync(0);
      }
      await sound.playAsync();
    }
  }

  // Use core library components to render elements
  return (
    <View style={[styles.container]}>
      <Button title="Play Sound" onPress={playSound} />
    </View>
  );
}

// Style components with CSS-like properties
const styles = StyleSheet.create({
  container: {
    flex: 1,
    justifyContent: 'center',
    backgroundColor: '#ecf0f1',
    padding: 10,
  },
});


```

Let's dig in:

**State Management**: For the most part, you're writing React code. Hooks such as `useEffect` and `useState` work just as they do when writing for the web.

**Core Components**: A big difference, though, is that you'll be using React Native's Core Components instead of HTML elements. This ensures smooth transitions between the different platform environments. You can see me using `Button` and `View` as replacements for html `button` and `div` elements.

**Expo Libraries**: Expo comes with some great handlers for interfaces such as zooming and touch interactions. In my example, I'm using the [expo-av library](https://docs.expo.dev/versions/latest/sdk/audio-av/) to handle playing a sound on button click.

**Styling**: Very familiar to anyone who's used style objects in React. Knowledge of CSS translates largely here.

**Platform Exceptions**: Naturally, some devices handle logic differently. You'll see that I've added a check `if (Platform.OS === 'ios')`. Here, if running on an Apple device, I'm going to set the audio position back to the beginning of the track before playing again.

That's it! Once this renders out, we'll have a button playing the audio file passed into this component.


A Beginner's Intro to React Native in One Component


Very quickly becoming a big fan of Lynda Berry's work.

<iframe src="https://www.youtube-nocookie.com/embed/R1S1nhAKMS4?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/R1S1nhAKMS4)

From [an interview with NPR](https://www.npr.org/2019/11/27/782921983/cartoonist-lynda-barry-drawing-has-to-come-out-of-your-body):

> One of the things you'll hear people say, when they tell me they wish they could draw, is, "I see it in my head, but I can't get it onto the page." And then I have to remind them that what they're seeing in their head is not a drawing. Drawing is something that has to come out of your body. And that horror they have is the same horror they might have if a bodily fluid was suddenly released, like suddenly they got a bloody nose or started drooling. It's that same shame about this thing that's out of their control that seems to be coming from them.
>
> My task — and it can be done within 30 minutes — is to get them past that. ... The easiest way to do that is to have them close their eyes and draw. ... The trick is to show them that there's another kind of drawing that is very different than representational drawing.
>
> There are different goals.
>
> Sometimes the drawing that's left over is not as important as the fact that it can transform your mood. You can transform the way that you feel about something. You can crack you up. I mean, you can crack yourself up with an index card and a letter pen. I think it's pretty interesting.


Getting It on the Page


![Louis!](https://padilla-media.s3.amazonaws.com/blog/art/sketches-2024-03-16.jpg)

Listened exclusively to early Hot Five and Hot Seven recordings of Louis Armstrong the other week. Nothing better to brighten your mood!


Satchmo


My intro to databases was through MongoDB. Coming from a web development perspective, it was comfy! Documents look and work like JSON objects. They're flexible and can adapt to changing schemas. I've enjoyed it!

I'm dipping SQL this week to broaden my horizons in data land. The first conceptual overview I got was this:

- SQL databases are Relational Databases
- Other database structures are Non-Relational, or NoSQL Databases

So are relationship structures exclusive to SQL?

## SQL

The "relational" distinction comes from the fact that data is stored within tables in SQL.

My e-commerce app would divide its data into three tables:

- User
- Items
- Orders

Each table for each would have data pertaining specifically to that category of data. They'd then be linked through a relationship.

Orders, for example, would have a many-to-many relationship with items. Many items can be in many orders. Many orders can have many items.

Users could have a many-to-one relationship with Orders. A user can have many orders, but an order is tied to only one user.

So when your querying the items in the user's order, SQL has to travel through a few relationships:

1. We start with the user ID
2. We query an order based on the user
3. We query items based on what's contained in the order
4. We get massage the data to show what's relevant to our query.

And thus, SQL gets the relationship monicker.

## MongoDB

What made this confusing at first is that MongoDB falls under the non-relational database category, but I can make these same queries in MongoDB as well.

[MDN has a terrific guide to Express and Databases](https://developer.mozilla.org/en-US/docs/Learn/Server-side/Express_Nodejs). When setting up the DB schema for MongoDB, [it's done with a relational structure](https://developer.mozilla.org/en-US/docs/Learn/Server-side/Express_Nodejs/mongoose#designing_the_locallibrary_models). In their library example, there are schemas developed for books, authors, book instances, and genre. All of which are tied together through relationships. In mongo, the ID is used to connect these documents.

So the NoSQL descriptor is a more accurate lead. The query language is different, but relationships are still an offering in Mongo.

The non-relational categorizing, though, is somewhat fair: The main benefit of Mongo is that you can nest in one document what you would otherwise split between tables.

A user document can store their orders within a nested object in MongoDB. Depending on your application, you may not be accessing orders outside of the context of a query to the user. [Mongo has a clear healthcare example](https://www.mongodb.com/databases/non-relational) where patient information is stored in their document


Non-Relational Database is a Misleading Name


[Matthew Hinsley's](https://www.matthewhinsley.com/) [Form & Essence](https://www.lulu.com/shop/matthew-hinsley/form-essence/paperback/product-dwke49.html?page=1&pageSize=4) quotes William Stafford's ["A Way of Writing"](http://www2.csudh.edu/ccauthen/451S12/staffort.html) —

> A writer is not so much someone who has something to say as he is someone who has found a process that will bring about new things he would not have thought of if he had not started to say them. That is, he does not draw on a reservoir; instead, he engages in an activity that brings to him a whole succession of unforeseen stories...For the person who follows with trust and forgiveness what occurs to him, the world remains always ready and deep, an inexhaustible environment, with the combined vividness of an actuality and flexibility of a dream. Working back and forth between experience and thought, writers have more than space and time can offer. They have the whole unexplored realm of human vision.

There is no certainty when you sit down to write. That's the magic! It's simultaneously a daunting aspect of the process as much as it is the whole spiritual point of doing it in the first place!

While explaining the importance of letting go of certainty in creative process, Matt shares this:

> Have you had a good conversation recently? Did you say something interesting, profound even?...If you did, I can almost guarantee that you were accessing your creative self. And I will also suggest that there's no way you could have given that advice, in that way, had you not been having that conversation. It was in the act of conversing, or reacting to energy and idea, that you put thoughts and experiences swirling in your subconscious together into words that became concrete statements in Form as they exited your mouth.

An anecdote to the blank page then is to make the creative process something other than closing the door, turning off the lights, and staring at a blank page. But instead, a conversation.

I've been in a rut with writing music. I haven't been brining reference into my practice. I've been sitting at the keyboard and simply waiting for what comes out. While there's an intuition that's part of the process, the energy is muted when starting this way.

But nothing kick-starts writing music better than listening to something I love, and then wanting to play around with it in my own way. In the same way that visual artists aren't cheating when they draw from reference, it's quite the opposite - the music is more buoyant and fun when it's in conversation with other recordings and musicians.

This conversation-style of creating is baked into the culture of blogging! Much of blogging is finding something you read that was interesting, then adding your own two cents while connecting it to a particular audience. You're adding your own story to the mix, telling the original author's tale in a way that adds a new dimension, compounding it's message, and creating a new audience for the source material.

Creatively conversing turns wonder into art.


Creativity as Conversation


I have a _need_ for _speed_ when developing. That goes for starting up all of my development applications.

Here's what needs to happen before I start coding:

1. Open my repo in VS Code
2. Load in any environment variables
3. Start the local server
4. Open up chrome
5. Visit localhost:3000

A short list. But it takes a few key strokes and mouse clicks to get there. I think I can do better!

**Linux Alias Commands** are the answer.

I have a few set up for a few different use cases. Here's the one the runs the recipe for the steps above:

```
alias cap="cd /Users/cpadilla/code/my-repo && code . && open http://localhost:3000 && source settings.sh && npm run dev
```

I'm adding this to my .zshrc file at the root of my account.

That turns all five steps into one:

```
$ cap
```

Another use case: I keep a list of todos in markdown on my computer. Files are named by the current date. I could do it by hand every time, but there's a better way:

```
alias dsmd="touch $(date +%F).md && open $(date +%F).md"
alias todo="cd /Users/cpadilla/Documents/Todos && dsmd"
```

There we go! `$(date +%F)` is a command for delivering a specific date format. The `todo` alias navigates to the correct folder and then uses `dsmd` to create and open the file.

Small quality of life changes! They add up when you do the same commands every day. 🙂


Chris Padilla/Blog

On This Day