
![🏂🐶](https://padilla-media.s3.amazonaws.com/blog/art/sketches-2025-05-17.jpg)

Just moved to Boulder, CO! Lucy's going to love it here.


SSX Lucy


From [Austin Kleon](https://austinkleon.com/2023/08/31/make-an-appointment-with-yourself/):

> The way I show up for myself, the way I discover who I really am, is to make an appointment every day to show up to the page. If I show up to the page, I show up to myself.

Two years of blogging! A small part of many years of creating and making, and it's certainly worth marking the occasion.

Last year I shared my [Lessons From a Year of Blogging](/firstblogversary). I'd largely echo those points this year. I still enjoy the clarity of thought that comes from writing and making, the ability to carry a long term conversation while leaving a trail, and having a stage to perform on.

One other thing I've come to appreciate with blogging as a medium is this:

**It's Malleable **

I took a moment to look back at what I've made this year. For context: This started largely as a text blog, mostly developer logs. Out of the soil, buds of more literary posts on what I was reading began to sprout. Soon after that, I started sharing art and music.

![🐟s](https://padilla-media.s3.amazonaws.com/blog/art/secondblogversary.jpg)

I've since traded words for color and sound! Lately I only write for my tech posts. And the switch is intentional — I want to get more miles out of music and drawing, and there are only so many hours in the day.

When I started, I was wringing my hands trying to decide what _one thing_ I would blog about. What a relief that it doesn't have to be one niche!

What I admire in the blogs I read is the spectrum of humanity that shines through. There's no predefined formula, and no algorithm to juice if you don't want to. So I end up seeing people as polyhedrons through the diversity they share and make.

On top of that, tomorrow I could decide that I'm all in on fly fishing. There's no barrier to me making this blog all about that for a couple of years. And I would revel in being able to look back fondly on the different phases and eras.

---

Starting out, I was worried about the idea that, if no one read what I wrote, I'd be doing all this for nothing. Turns out the rewards that come from a creative act alone absolutely eclipse any hit to the ego I would take if a post gets overlooked!

Elizabeth Gilbert in [_Big Magic_](https://www.goodreads.com/en/book/show/24453082):

> You might end up dancing with royalty. Or you might just end up having to dance alone in the corner of the castle with your big, ungainly red foam claws waving in the empty air. that's fine, too. Sometimes it's like that. What you absolutely must not do is turn around and walk out. Otherwise, you will miss the party, and that would be a pity, because - please believe me - we did not come all this great distance, and make all this great effort, only to miss the party at the last moment.

---

And, of course, even if my inbox doesn't get flooded with mail on the eureka moment someone had reading a tech blog post, writing publicly is still a phenomenal tool for [clarifying thinking in that craft](https://chriscoyier.net/2022/12/13/writing-is-the-ticket-to-a-clear-understanding/).

---

I'm thinking much about the question offered through [James Hollis' work](https://www.goodreads.com/en/book/show/62039119): "What is seeking expression through me?" The wonderful thing about a personal blog is an opportunity to flexibly celebrate that expression.

The generous part of that showing up is that, by doing so, we then bring our fullest selves to the people we serve.

So start with where ever you are! Bring all parts of yourself along for the ride. You may find, as I have, it's an excellent way to explore the answers to that question.


Two Years of Blogging


Spring Boot is a well embraced and powerful framework for developing web applications. Getting a backend API setup is fairly quick and allows for a great deal of durability up front. A fine balance between moving quickly on an app while giving you the guard rails to maintain organization, scalability, and durability.

Here's the quick-start guide to getting an API setup:

## Layers

If you're used to the MVC pattern in software development, you'll find a similar intent of organization around Spring Boot Architecture. However, the categories we group our logic in will be slightly different.

In Spring Boot, these categories are referred to as layers of the application. They have their own directories and are bundled in their own package within the application.

Here's a simple directory structure within the `src` folder of our app:


```
project/src/main/java/com/projectname
|-- controller
|    |-- ArtistController.java
|-- model
|    |-- Artist.java
|-- repositories
|    |-- ArtistRepository.java
+-- service
     |-- ArtistService.java
```

Note that tests will live in their own directory outside of the `src` folder.

Above, all layers are represented:

- The **Controller** layer is responsible for connecting our data from the service layer with a means of rendering or presentation.
- The **Model** layer handles communication between our application and external database.
- The **Repositories** layer is responsible for querying logic to our database. If the model layer is establishing communication with the database, then the repositories layer is handling what type of requests we're making available to our application.
- The **Service** layer handles all the business logic for our application. This layer relies on the repositories layer to provide the data so that it then can be transformed in whatever way we need it to be before delivery.

## In Action

Ok! So say that I have my base app setup for a Spotify Popularity Monitor API. From here, I want to setup a feature for each layer that supports CRUD operations for an `Artist`. 

I'll start with the model:

### Model

```
package com.chrispadilla.spotifyperformancemonitor.model;

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

@Entity
public class Artist {
	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	private long id;

	@Column
	private String name;

	@Column
	private String[] genres;

	@Column
	private String spotifyId;

	@Column
	private String spotifyUrl;

	// Getters/Setters here
	
}

```

For brevity, I'm leaving out the Getters and Setters. What I'm showing is the schema for an Artist as I want it setup in my relational DB. 

By adding `@Entity`, I'm denoting this as a persistence layer class for the JPA.

Next, I'll add the repository:

### Repository

```
package com.chrispadilla.spotifyperformancemonitor.repositories;

import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;

import com.chrispadilla.spotifyperformancemonitor.model.Artist;

@Repository
public interface ArtistRepository extends CrudRepository<Artist, Long>{
	Artist findByName(String name);

	Artist findBySpotifyId(String spotifyId);
}
```

Fairly simple! Spring Repositories already come with several CRUD methods. I enable them by extending from `CrudRepository`. By default, I'll be able to call `findById`, but if I want to query by another field, I specify it on the interface with a method. I've done this with `findByName` and `findBySpotifyId` above. Spring will automatically make the connection that if I'm passing in a variable `spotifyId`, that this is what I'm querying by on the model. No extra logic required!

### Service

The service layer will largely depend on what I'm trying to do with the data. It goes beyond the scope of today's blog, so here's the bare bones setup for a service class:

```
package com.chrispadilla.spotifyperformancemonitor.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.chrispadilla.spotifyperformancemonitor.model.Artist;



@Service
public class ArtistService implements IArtistService {
	@Autowired
	private ArtistRepository artistRepository;
		

	public void collectArtist(String spotifyId) {
		// Do your stuff
	}

}

```

It's good practice to create an interface outlining the methods you'll implement, so here I'm extending from an `IArtistService` instance above.

Again, an annotation of `@Service` marks this as a bean that can be injected throughout my other layers.

### Controller

It all comes together in the controller! Here I'll setup a controller to GET and POST artists:

```
package com.chrispadilla.spotifyperformancemonitor.controller;

import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.server.ResponseStatusException;

import com.chrispadilla.spotifyperformancemonitor.model.Artist;
import com.chrispadilla.spotifyperformancemonitor.repositories.ArtistRepository;
import com.chrispadilla.spotifyperformancemonitor.service.ArtistService;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;


@RestController
@RequestMapping("/api/artist")
public class ArtistController {
	@Autowired
	private ArtistRepository artistRepository;
	@Autowired
	private ArtistService artistService;

	@GetMapping
	@ResponseStatus(HttpStatus.OK)
	public Iterable<Artist> getArtists() {
		return artistRepository.findAll();
	}

	@GetMapping("/{id}")
	public Artist getArtist(@PathVariable Long id) {
		Artist artist = artistRepository.findById(id)
			.orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND, "No matching ID"));
		return artist;
	}

	@PostMapping
	@ResponseStatus(HttpStatus.CREATED)
	public Artist postArtist(@RequestBody Artist artist) {
		return artistRepository.save(artist);
	}
}

```

Several nice annotations are made available here! `RequestMapping`, `GetMapping`, and `PostMapping` allow us to define the path for our controller. `PathVariable` gives access to the `id` that's listed as part of my path in my get request. 

Here, you'll see I'm using `Autowired` to tell Spring to inject an instance of my repository and service layer classes created above. I can then use them freely within my controller.

It can be tempting to write the business logic directly in the controller. To maintain flexibility, though, it's best to leave minimal db logic in the controller and wrap up data transformation within a method on your service layer classes. This allows for a more highly decoupled system. Were I to add a **Presentation** layer, it would be far simpler to access the service layer object, as opposed to refactoring a bloated controller method. 


### That's It!

With just a few files written, we have a strong basis for a flexible and easily extendable API! All with type checking along the way and a largely decoupled system! 👏



Layers in a Java Spring Boot API


My domain renewed and my blog turned [a year old](/compg)! What started as a fun technical project has turned into a wildly gratifying medium for expression. I'm starting to think it might even become [my life's work](https://austinkleon.com/2020/09/09/15-years-of-blogging-and-3-reasons-to-keep-going/)!

I've learned **a ton** in the process of writing a bit each day. The first draft of this has a list of bullet points a mile long. Here are some of the most salient takeaways, and why I'll keep writing:

## Performing on a Stage

The process truly is the product. The greatest gift of sharing online isn't _really_ so that thousands of strangers can see what you create. It's in the making.

But there's something to performing on stage that's different than the practice room.

It's the feeling of elevation and a sense of audience that can really stir the spirit. I write for myself everyday in a journal. But I don't quite reach the same clarity of thought or spiritual sense of communing with the _Great Creator_.

Put another way — sure, in school you might doodle on your math homework. But when given a canvas that will be framed on a wall, there's a calling to create something more.

Maybe that's overstating things here. It's _just_ a blog, after all.

But the feeling is there. It was the same with music. An audience of 3 is still an audience in a concert hall. Any audience is enough to [complete the performance](/stanchfield).

## Clarity

I thought this was just a point for software, but it goes beyond that.

Writing about code helps clarify thinking around it. That goes for writing what I'm learning, topics reading about, and projects I've built. It even goes for [testing](https://www.chrisdpadilla.com/testingandwriting).

Turns out, the same is true for everything else. Writing a post about creativity solidifies my thoughts around it. I've had moments in the studio where I was stuck on something, but remembering "hey, didn't you write a blog post about practicing slow?" actually came up.

There's the technical side of it, too. Wanting to record a guitar tune for this site makes my practice on it that much more focused. Same for art — having a platform to share pushes me to want to refine my line quality and try new skills.

Kleon makes a good point that [writing helps him figure out what he has to say](https://austinkleon.com/2020/09/09/15-years-of-blogging-and-3-reasons-to-keep-going/). The more I write, the more I feel a _writing voice_ coming through. I become aware of what's valuable in what I have to say through — well — saying things.

## Long Term Conversations

Alan Jacobs mentions that the best part of blogging is [revisting themes and topics](https://blog.ayjay.org/on-blogging/).

> Everyone who writes a blog for a while knows that one of the best things about it is the way it allows you to revisit themes and topics. You connect one post to another by linking to it; you connect many posts together by tagging. Over time you develop fascinating resonances, and can trace the development of your thought.

I'm just at the start, but I'll echo that already it's been fascinating holding a long term conversation with myself and other blogs and books.

## It's Surprisingly Expressive

It's a great answer to the equation of [Impression Munis Expression Equals Depression](/impressionminusexpression)

You know how there's probably that thing you're really into that's pretty niche (say, vintage radio collecting?) Or maybe the work you do is too technical to be good small talk fodder? Or maybe you just have those sensations, feelings, and impressions that are too nuanced to express in a passing conversation? Yeah, writing is good for that.

What makes a personal blog interesting is bringing in the full spectrum of what tickles your brain. Somedays it _is_ executing SQL queries through Python, other days it's musings on books, other days it's leaving memories from a fun weekend. Some of my favorite tech blogs have a wild amount of personality shining through them. It's fun to have [many pots boiling](/manypotsboiling)!

All creative practices are actually really similar once you get past the details of medium. If you want an outlet but don't feel like you're creative ("I couldn't sing my way out of a paper bag!", "I can only draw stick figures!",) I think you ought to try blogging. You're a Mozart in your own way of speaking and living. Words are a pretty great way to capture your impressions.

## 👋

A year is just the start. [Many](https://chriscoyier.net/) [of](https://austinkleon.com/) [the](https://twitter.com/everydaylouie?ref_src=twsrc%5Egoogle%7Ctwcamp%5Eserp%7Ctwgr%5Eauthor) [folks](https://sive.rs/) I admire are prolific and diverse bloggers. If you've read, commented, emailed, or been a part of it in anyway — Hey! Thanks! Here's hoping for many more years!


Lessons From a Year of Blogging


I have a nasty habit of holding my pencil with a mean pinch. I can't write for too long because my palm will get sore.

It's something I'm being mindful of now that I'm drawing regularly.

How it probably happened:

1. Go to school, learn how to hold a pencil properly
2. Before I nailed that, I had to learn to write accurately - hitting the tops of my letters on the dotted lines
3. Strain a bit to get it right, trading good form for accuracy
4. The bad habit solidifies once accuracy became more important than technique

It's easy to imagine that in other disciplines, and on a much more serious scale. On sax, I knew folks that developed tendonitis. I've heard of artists with Focal Dystonia. Even when I taught marching band, I saw students push themselves to overexertion.

So I'm stopping to ask myself: What if it were flipped? What if the way I did things was more important than the end result?

Here's how it's going so far with drawing: _comically_!

My lines were already pretty inaccurate, now they're hilariously so! It's both frustrating and...fun!?

It's been a weird cheat for another benefit. Focusing more on how I'm holding the pencil has made it so I can let go of the result. In other words, drawing is even more playful than it was before!

I'm already translating this to guitar and piano to pretty great effect. Things are moving more slowly, but I don't leave either instrument with any cramps. Since the physical process was more pleasurably, lo and behold, I'm feeling even more bouncy and light after leaving a session.

W.A. Mathieu has a great essay in [The Listening Book](https://www.goodreads.com/en/book/show/13136146) that advocates for practicing slowly. The message is different: practice slowly to learn quickly. But the sentiment is similar:

> _Lentus Celer Est_
>
> This is bogus Latin for Slow (lentus) Is Fast (celery). Write it large somewhere. It means you cannot achieve speed by speedy practice. The only way to get fast is to be deep, wide awake, and slow. When you habitually zip through your music, your ears are crystallizing in sloppiness.
>
> Yet almost everyone practices too fast, their own music as well as others'. We want to be the person who is brilliant. This desire is compelling, and it can become what our music is about.
>
> Pray to Saint Lentus for release from zealous celerity. Pray for the patience of a stonecutter. Pray to understand that speed is one of those things you have to give up—like love—before it comes flying to you through the back window.

Does it have to stop there? There's a big life metaphor here, I bet! Say: setting up your days where you actually enjoy them, have energy to do the most important things, and in a way that sustains relationships.

I'm going to keep trying: Holding days and practices with a loose grip.


Chris Padilla/Blog

On This Day