I have been using [Raycast](https://www.raycast.com/) long enough to say that it has become foundational for my daily routines. At least digital [routines](https://www.0xshapeshifter.dev/uses).

```cv
gallery
{"layout":"hscroll","images":[{"src":"https://firebasestorage.googleapis.com/v0/b/maitake-project.appspot.com/o/pages%2FlvJ3IR86vicGl3jkeINujb4Kah12%2Fraycast-snippets%2F18880fbb-a2fd-4477-aee4-6dacfa0dd57c.jpg?alt=media&token=563a5bbf-6fdc-4150-9567-51d6ba7abbfb","id":"18880fbb-a2fd-4477-aee4-6dacfa0dd57c","width":864,"height":529,"filename":"tempImagerzbIaB.jpg","type":"image/jpeg","caption":"","border":false}]}
```

*Snippets* is one of the core features of Raycast. Essentially, a snippet is an extendable piece of text that helps avoiding boilerplate text/code, as well as extra unneccessary typing. That being said, snippets represent the [DRY principle](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself) in action.

For example, snippets can be used for filling:

* Email address;

* Address;

* Phone;

* Email reply;

* Video-call invite;

### How to create a snippet

Open Raycast → Select "Create a snippet" → Fill the form → Tada!

* \*Name\* = the title to be \*displayed\* in Raycast;

* \*Snippet\* = the text to be \*inserted\*;

* \*Keyword\* = the word that \*triggers\* a snippet;

```cv
gallery
{"layout":"hscroll","images":[{"src":"https://firebasestorage.googleapis.com/v0/b/maitake-project.appspot.com/o/pages%2FlvJ3IR86vicGl3jkeINujb4Kah12%2Fraycast-snippets%2F9ad5d78e-dae6-4598-95e7-40efdd2203a6.jpg?alt=media&token=9a58b54f-81ce-4139-8040-9a50b1a271b4","id":"9ad5d78e-dae6-4598-95e7-40efdd2203a6","width":864,"height":529,"filename":"tempImageqooixW.jpg","type":"image/jpeg","caption":"","border":false}]}
```

### Snippets I use

I use find myself using snippets quite often. Below you ca find several less conventional use cases I often rely on.

\### Dates

Weekday, for my weekly notes

```

{date format="YYYY"}-W{date format="ww"}


{date format="yyyy-MM"}
```

\### Zettelkasten ID

[Zettelkasten](https://zettelkasten.de/introduction/) note id, for a file naming convention when creating notes. NB: I use [helix](https://www.0xshapeshifter.dev/uses#software)for 99% of my writing, so the snippet works best when dealing with terminal-based interaction:

```

{date format="yyyyMMddhhmm"}.md
```

\### Frontmatter

Since I moved my blog to [Zola](https://www.0xshapeshifter.dev/workshop/zola-intro), having a consistent frontmatter has become a great convenience:

```
+++
title = "{cursor}"
description = ""
date = "{date format="yyyy-MM-dd"}"
updated = "{date format="yyyy-MM-dd"}"
draft = false
template = "page.html"
[extra]
source = ""
type = ""
+++
```

\### Youtube RSS template

I don't watch Youtube per se if I am not looking for a specific tutorial. I prefer RSS feeds over social media. The thing below helps receiving some YT channel updates via RSS, just add the channel id.

```
https://www.youtube.com/feeds/videos.xml?channel_id={cursor}
```

\### Creating code projects

I often find myself relying on snippets when running repetitive code tasks  such as installing packages, creating projects and whatnot. For example:

```

rails new {cursor}


lsof -PiTCP -sTCP:LISTEN


pnpm create svelte@latest {cursor}
```

### Conclusion

Raycast is a great and super extendable launcher that allows fine-tuning one's experience to a pretty high degree. And snippets is often underrated yet super powerful feature.

### See also

* [Raycast Manual](https://manual.raycast.com/)

* [Snippets Manual](https://manual.raycast.com/snippets)

* [Dynamic Placeholders](https://manual.raycast.com/dynamic-placeholders)

Raycast Snippets

Pema Chodron shares Rinpoche’s olders son memories about his father. Essentially, he has always been looking for ways to introduce some disturbance. Not proactively, but meaningfully. For example:

> ***He himself used to wear an obi, the wide belt that goes with a kimono, underneath his clothes, really tight, so that if he slouched, he would be uncomfortable—he had to keep his “head and shoulders”…***

These little things helped to stop something what Rinpoche called “shopping” — a constant pursue for “better” options. This perfectly aligns with the idea of comfort as the most human thing.

Modern interfaces are built to be smooth and easy to use. They are fine-tuned for consumption and grabbing attention. What if by introducing little disturbances via interfaces, one could help people gain and maintain more consciousness while using digital tools.

What if, by creating *decentralizing interfaces* one could help breaking the circle of mindless consumption.

## See also:

* Chödrön P. (2018). The Wisdom of No Escape: and the Path of loving-kindness. Boulder, Colorado: Shambhala Publications, Inc.

* [Meta-Moments: Thoughtfulness by Design](https://alistapart.com/article/meta-moments-thoughtfulness-by-design/)

First published [here](https://www.0xshapeshifter.dev/journal/decentralizing-interfaces/).

Decentralizing interfaces

Originally published: [here](https://www.essens.dev/journal/zenful-knowledge-gardening).

I know what you might think: a *zenful knowledge garden* is yet another shiny, fancy way of saying “I write things I find interesting”. Some people call this practice “personal knowledge management”[1](https://www.essens.dev/journal/zenful-knowledge-gardening#user-content-fn-1), others refer to is as “personal information management”[2](https://www.essens.dev/journal/zenful-knowledge-gardening#user-content-fn-2). To manage ideas, thoughts, and information, some rely on the “second brain approach”[3](https://www.essens.dev/journal/zenful-knowledge-gardening#user-content-fn-3) or zettelkasten[4](https://www.essens.dev/journal/zenful-knowledge-gardening#user-content-fn-4), others practice “systems of small dots”[5](https://www.essens.dev/journal/zenful-knowledge-gardening#user-content-fn-5).

At the end of the day, it’s all about three things:

* *capturing* ideas, or quotes from books and whatnot;

* *organizing* what was captured — as in storing *in a way that one could always find it in a context*;

* *reusing* information and building upon it.

## zenful knowledge gardening

I call my knowledge management practice a *zenful knowledge gardening* for several reasons.

First, I have been playing with the systems mentioned above for long enough to discover a thing about myself: when I tend to replicate a practice in a “pure” way, I tend not to practice what the thing was indented to help with. That is, I don’t manage knowledge, I set up plugins for Obsidian. If you know, you know.

And because of that I wanted to have something that would help me *focus* on absence of external noise, on knowledge rather than playing by the rules of environment. Hence, *zenful*.

Secondly, I don’t like the *management* part in “knowledge management” because it smells like misplaced priorities to me. That is, personally, I don’t manage my memory, don’t achieve goals, don’t do benchmarks. My idea is to slowly but surely establish this inner dialog between my memory, experience, and knowledge. It’s a slow, methodical process. Hence, *gardening*.

## tools of trade

For the longest time, I have been using laptop and my phone as this digital duo. But I felt that something had always been missing. Something that could reduce smoothness in exchange for mindful presence[6](https://www.essens.dev/journal/zenful-knowledge-gardening#user-content-fn-6). Something that would make me actually return to what had been written.

Moreover, I felt this urge to drastically reduce the number of apps that I use to *sustain* my day-to-day. A couple of years back I was using something like 10 apps daily. Which sounds like overcompensation for me.

So my *zenful knowledge gardening stack* had to be minimal, essential (as in screw-level essentialism), and it had to play well with my most time-consuming activity: writing code.

Eventually, I settled with:

* [Helix](https://helix-editor.com/) as my go-to editor. Which comes with [marksman lsp](https://github.com/artempyanykh/marksman/tree/main) in case you’re into these things;

* a notebook of the “[field notes](https://fieldnotesbrand.com/)” type so that I can carry it everywhere;

* a pen, something like [Fischer space pen](https://www.spacepen.com/);

## capturing modes

There are two main scenarios that trigger the gardening chain reaction.

**Scenario #1: Work-mode**. If I am in front of my computer, I have my terminal opened by default. In 90% of cases there’s a Helix tab somewhere as well. This means I can always create a note: no need to context-swith to a different window, or (god forbid) open another app.

**Scenario #2: Non-work-mode**. If I am not in front of a computer — doing chores, or out and about, — I radically *de-digitize* my experiences. The most “digital” part of it is listening to a podcast while I am doing dishes, for example. If I need to capture something, I use my notebook and a pen, or I record a voice memo in case I am driving.

No matter the scenario, a note is always created with a unique id: `yyyyMMddHHmm` (full year, month, day, hours, minutes, for example “202403131555”). That is, every note — digital or hand-written — has its id based on the moment it was taken.

It allows for easy referencing in future — no matter the medium. For example, my blog metadata includes the `zettelkasten` field so that I could always know where the post comes from, and what its original source.

## migration

Most of what some call “fleeting” and “resource” notes[7](https://www.essens.dev/journal/zenful-knowledge-gardening#user-content-fn-7) I write by hand in my notebook. This means (ideally) at the end of every week I take my time to migrate them to the digital garden. Yes, type them all. Yes, by hand.

Such processing allows for intentional reflecting, filtering, and deep diving into what seemed interesting and important.

That is why I call this *gardening* — periodically you have to collect the seeds, and to plant them.

## the real gardening

”It’s all good, but we know that plants need watering, don’t they?” — one could ask. That’s true. That’s why (ideally) at the end of every day I tend to work on a fleeting note to make it evergreen. That is, I find a note that is marked as “fleeting”, and try to make them into short essays, or what I call “slips”. But I tend to perceive them as *evergreen*[8](https://www.essens.dev/journal/zenful-knowledge-gardening#user-content-fn-8), rather than *permanent* notes[9](https://www.essens.dev/journal/zenful-knowledge-gardening#user-content-fn-9). In plain human, I treat every note — even those I publish on my blog — as entries that can always grow and develop with time. That’s why, for example, I have this `updated` section inside every blog entry.

## conclusion

Capturing thoughts, ideas, positions, arguments — is an important part of my routine. It helps me seeing the world from many points of view and learn to interact with these positions. Throughout the years I have tried dozens of note-taking apps, knowledge management approaches, and whatnot. And I discovered that the most simple and (in some way) manual approach enables knowledge retention as well as make my *knowledge curation more mindful*. Not only that: constantly engaging with my past self through rereading my notes, rewriting them, gives an unmatched pespective on the fluidity of time, and the nature of humanity. Which, in turn, enables more thoughtful relationships both with myself and others.

## footnotes

1. [Personal knowledge management](https://en.wikipedia.org/wiki/Personal_knowledge_management) [↩](https://www.essens.dev/journal/zenful-knowledge-gardening#user-content-fnref-1)

2. [Personal information management](https://en.wikipedia.org/wiki/Personal_information_management) [↩](https://www.essens.dev/journal/zenful-knowledge-gardening#user-content-fnref-2)

3. [Building a Seconf Brain](https://www.buildingasecondbrain.com/) [↩](https://www.essens.dev/journal/zenful-knowledge-gardening#user-content-fnref-3)

4. [Introduction to the Zettelkasten Method](https://zettelkasten.de/introduction/#the-anatomy-of-a-zettel) [↩](https://www.essens.dev/journal/zenful-knowledge-gardening#user-content-fnref-4)

5. [Linking Your Thinking](https://www.linkingyourthinking.com/) [↩](https://www.essens.dev/journal/zenful-knowledge-gardening#user-content-fnref-5)

6. [Decentralizing Interfaces](https://www.essens.dev/journal/decentralizing-interfaces) [↩](https://www.essens.dev/journal/zenful-knowledge-gardening#user-content-fnref-6)

7. [How To Take Smart Notes](https://fortelabs.com/blog/how-to-take-smart-notes/) [↩](https://www.essens.dev/journal/zenful-knowledge-gardening#user-content-fnref-7)

8. [Evergreen notes](https://notes.andymatuschak.org/Evergreen_notes) [↩](https://www.essens.dev/journal/zenful-knowledge-gardening#user-content-fnref-8)

9. [From Fleeting Notes to Project Notes](https://zettelkasten.de/posts/concepts-sohnke-ahrens-explained/) [↩](https://www.essens.dev/journal/zenful-knowledge-gardening#user-content-fnref-9)

Zenful Knowledge Gardening

For as long as I remember, I have been practicing note-taking. It all started with notebooks, pen and paper. At the time I was just writing down some quotes I have read or heard. Gradually these little bits and pieces have become foundational for ideas, thoughts and little essays. I have been pen-and-paper person much longer than it was not trendy with the wide spread of digital tools. And a little longer — it even has become trendy eventually.

Jokes aside, unconsciously I have been practicing *thinking via writing* for my whole life. But only when I started exploring the existing tools for thought — such as capturing tools (note-taking apps) and reading companions ([Matter](https://hq.getmatter.com/), [Reader](https://readwise.io/read) from [Readwise](https://readwise.io/)), I started noticing two things.

The first is *decline in thinking bandwidth capacity.* The more I was exploring things that could “extend my mind”, I experienced my mind narrowing. I think this is due to the fact that my mind has become preoccupied with thinking about “how to become more proficient with the tool”, instead of exploring and generating thoughts and ideas.

The second thing is that I actually *stopped writing* consistently, and I *switched to collecting* stuff — links, books, articles and such. That is, I have become someone chasing for “more things to process”, “more highlights to add”, — instead of being someone actually processing things. Or, rather — instead of being someone who proactively practices analyzing, distilling, noticing — thinking.

I figured it’s not the way to go. I actually love thinking through writing. And I absolutely didn’t like the feeling that I get. I almost felt maniacal at times. So I decided to try a different thinking stack. My previous “(not)-thinking” environment consisted of: [Obsidian](https://obsidian.md/), [Nota](https://nota.md/), [Readwise](https://readwise.io/), [Reader](https://readwise.io/read), [Matter](https://hq.getmatter.com/). Here, Obsidian was the ring to rule them all (most of the time through plugin crutches). My new “(hopefully)-thinking” stack includes Apple Notes, [Reader](https://readwise.io/read), physical notebook + a pen. No synchronization, no fancy plugins. Only ideas, thoughts, and consistent practice of chiseling things that truly matter. With time, I will share more, but now I feel like *deliberately injecting more friction* is the way to go.

Tools for thoughts: back to the roots

What is gardening? Is it just about maintaining one's natural environment in the long term? Or is it simply helping nature grow and flourish? I believe there's a bit more to it.

First, gardening is a practice. It involves taking a "head down," zen-like approach to doing things in order to reap compounding effects in the future. This means regularly watering the plants, nurturing them, and giving them access to sunlight. Generally speaking, by consistently attending to any practice, one builds resilience and confidence while establishing a strong foundation.

Second, it has a long-term and constantly unfolding perspective. When your friend shows you their garden, all you see is the result - a status. Even though you know that your friend put a lot of time and effort into it, the garden for you is just an immediate state. You can't remember how it was growing, for example. However, every good gardener knows that a garden is never just a state; it's not actually a noun.

It's a process that continually unfolds, and we help it grow by practicing the art of gardening. That is, by giving it what it needs and reducing things that can harm it. Gardening is also never short-term. It involves waiting as a natural part of the process.

Third, gardening is about creating something to be admired. A garden brings joy not only to the gardener but also to those passing by or visiting. Gardening has been a part of a social display game that people have played since the 16th century BC, making it over 3500 years old. That is, gardening is done partly to be looked at — by strangers.

To me, gardening is a metaphor for maintaining a sustainable social media presence. We live in an age where offline and online practices are intertwined, and it's natural to feel overwhelmed by the constant influx of information. Some inputs can be productive, while others are not.

In this sense, digital gardening is a set of practices that I have developed. These practices focus on maintaining my tools and presence in the digital and online environment. For example, I consider my website as one of my gardens. To maintain it, I publish new articles, findings, and thoughts to keep it up to date with information about who I am, what I'm all about, and what my plans are. My website serves as my digital headquarters, and when guests visit, I want it to be clear, helpful, and useful.

I don't stress over it — I use it (and abuse it: it went through too many redesigns). I understand the importance of taking care of it, finding and fixing bugs, correcting typos (I make a lot of typos), and adding small features. To those familiar with bonsai, this might sound relatable.

Approaching my digital and online presence through the lens of gardening helps me stay sane, focus on producing signals over noise, and adopt a different perspective. I believe people often share a lot and quickly to "stay visible," on social media, but I personally don't find this neither useful not healthy. So the gardening approach, which requires patience, not only teaches me to share more meaningful things but also prevents me from contributing to the social status race induced by social media that my mind would otherwise happily join.

To sum it up, digital gardening is the practice of maintaining one's social media (and digital) presence (and tools) by taking care of it when necessary and contributing something meaningful rather than opting for the default race of "*more*".

Originally published on my [website](https://www.0xshapeshifter.dev/journal/digital-gardening).

Digital Gardening

[Zola](https://www.getzola.org/) is a static site generator (SSG) written in [Rust](https://www.rust-lang.org/). It relies on [Terra](https://keats.github.io/tera/) template engine. That’s all for the technical nerd speak, let’s get to building.

Start by initialing the project. Run:

```
zola init myblog
```

There will be several prompts. Provide a website address (can be a dummy). Also, feel free to reply **`N`** to all of them, we will configure everything afterwards.

## Structure

By default, the generator expects this project structure:

```
├── config.toml
├── content/
│   └── blog/
│       ├── _index.md
│       ├── first.md
│       └── second.md
├── sass/
├── static/
├── templates/
│   ├── base.html
│   ├── page.html
│   ├── list.html
│   └── index.html
└── themes/
```

Here’s how it works:

* **`config.toml`** — is responsible for the website configuration. Title, author, RSS, and everything;

* **`base.html`** — functions as a main template for the website aka layout;

* **`index.html`** — is exactly what you think it is;

* **`list.html`** — is the template, responsible for displaying lists (of posts, for example);

* **`page.html`** — the template that diplays contents of a post. Namely, it is where **`.md`** content is rendered;

## Templates

Create the **`templates/`** folder.

Let’s begin with the **`templates/base.html`**:

```
<!DOCTYPE html>
<html lang="en">

<head>
  {% include "head.html" %}
</head>

<body>
  <main>
    {% block content %} {% endblock %}
  </main>
  {% include "footer.html" %}
</body>

</html>
```

Notice there are placeholders for **`head.html`**, **`navigation.html`**, and **`footer.html`**. Let’s create those as well in the **`templates/`**.

```
# head.html
<meta charset="UTF-8">
<meta content="IE=edge" http-equiv="X-UA-Compatible" />
<meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no" />
<meta name="robots" content="index, follow">
```

```
# footer
<footer>
  My super cool blog 2024
</footer>
```

Notice: in **`navigation.html`** there are some items coming from **`config.extra`**. We are going to create them next.

```
# navigation
<nav>
    {% for item in config.extra.navigation %}
      <a
      href="{{ item.url }}">{{ item.name }}</a>
    {% endfor %}
</nav>
```

Lastly, let’s create **`templates/general.html`** for pages like index, contact, etc:

```
{% extends "base.html" %}
  {% block content %}
    <h1>
      {% if section.title -%}
        {{ section.title }}
      {%- endif %}
      {% if page.title -%}
        {{ page.title }}
      {%- endif %}
    </h1>

    <p>
      {% if section.description -%}
        {{ section.description }}
      {%- endif %}
      {% if page.description -%}
        {{ page.description }}
      {%- endif %}
    </p>

    <article>
      {% if section.content -%}
        {{ section.content | safe }}
      {%- endif %}
      {% if page.content -%}
        {{ page.content | safe }}
      {%- endif %}
    </article>
  {% endblock content %}
```

## Configuration

In Zola, **`config.toml`** is the source of truth. There, we put the project’s title, description, RSS, navigation (if you prefer), and everything else. Don’t forget to check out [Zola Docs](https://www.getzola.org/documentation/getting-started/configuration/) for more. Here’s a sensible starter:

```
base_url = "https://my-cool-blog.com"
title = "Your blog's title"
description = "The description goes here"
default_language = "en"
minify_html = true
generate_feed = true
feed_filename = "atom.xml"
author = 'Arya Stark'
compile_sass = false
build_search_index = false

[markdown]
render_emoji = true
external_links_target_blank = true
external_links_no_follow = true
external_links_no_referrer = true
smart_punctuation = true
lazy_async_image = true

[link_checker]
internal_level = "error"
external_level = "error"

[slugify]
paths = "on"
anchors = "on"

[extra]
navigation = [
  { url = "/now", name = "now"},
  { url = "/journal", name = "journal"},
  { url = "/workshop", name = "workshop"},
  { url = "/bookmarks", name = "bookmarks"},
]
```

## Content

The conten will live in a dedicated folder. Let’s create it: **`/content`**. Here we are going to have subfolders. Think of them as types of content you post: blog posts, videos, or podcast episodes. We can hav as many subfolders as we want. For example, I settled for *journal*, *workshop* and *bookmarks* for my personal website.

Such *sections* can include **`_index.md`**, which defines the content and metadata for the section. Let’s create **`content/blog/_index.md`**.

```
+++
title = "I am a section title"
description = "I am a section description"
template = "list.html"
paginate_by = 8
sort_by = "date"
+++
```

Mind the dividers **`+++`**.

It all starts with frontmatter. By default, **`_index.md`** is for listing content. But you can write some markdown as well. It will be rendered on the section page consequently.

Les’t create a couple of articles. Now, in **`content/blog/`** create **`article1.md`**:

```
+++
title = "Article title"
description = "Some fancy description can go here as well"
date = "2024-01-05"
draft = false
template = "page.html"
+++

# Heading 1
Ut culpa quis et ut nulla occaecat elit ad commodo consequat. Ea nostrud ut adipisicing et ipsum nostrud cillum non magna in ad. Est reprehenderit exercitation excepteur ut laborum minim non occaecat amet. 

## Heading 2
Laborum aliqua duis commodo irure anim occaecat Lorem deserunt. Dolore dolor adipisicing ad sint non dolor ut Lorem consectetur fugiat quis. In aute non in amet velit ut dolor adipisicing magna reprehenderit incididunt labore incididunt.

### Heading 3
Esse proident ullamco id adipisicing velit ad do sint nisi commodo consectetur. Commodo enim consequat eu dolore aliqua pariatur consectetur eiusmod quis minim ut irure. Non aliquip laboris occaecat sunt adipisicing nisi occaecat occaecat esse Lorem ullamco. 

- Bullet 1
- Bullet 2
- Bullet 3

1. Argument 1
2. Argument 2
3. Argument 3

>Some super smart quote
```

## Render content

How to render it? Hint: notice the **`template`** field in both frontmatters above. Let’s create them, starting with **`templates/list.html`**:

```
{% extends "base.html" %}
{% block content %}
  <h1>{{ section.title }}</h1>


  <ul>
    {% for page in paginator.pages %}
        <li>
          <a href="{{ page.permalink | safe }}">
             {{ page.title }}
          </a>
        </li>
    {% endfor %}  
  </ul>


{% if paginator %}
  {% if paginator.previous %}
    <a href="{{ paginator.previous }}">&#8592; Previous</a>
  {% endif %}
    {% if paginator.next %}
      <a href="{{ paginator.next }}">Next &#8594;</a>
    {% endif %}
  {% endif %}

{% endblock content %}
```

Next, let’s create **`templates/page.html`**:

```
{% extends "base.html" %}

  {% block content %}
    <h1>{{ page.title }}</h1>
    <article>{{ page.content | safe }}</article>

    
  {% if paginator %}
    {% if paginator.lower %}
      <a href="{{ page.lower.permalink | safe }}">&#8592; Previous</a>
    {% endif %}
    {% if paginator.higher %}
      <a href="{{ page.higher.permalink | safe }}">Next &#8594;</a>
    {% endif %}
  {% endif %}
  {% endblock content %}
```

## Style

There are many tools that allow creating great-looking interfaces. If you prefer working with plain *css*, create **`static/style.css`** and work here. Or, if you like working with [Tailwind](http://127.0.0.1:1111/workshop/zola-intro/tailwindcss.com), the simplest way is to update your **`head.html`**:

```
<script src="https://cdn.tailwindcss.com?plugins=forms,typography,aspect-ratio,line-clamp"></script>
```

## Conclusion

Zola is a great site generator: easy to use, it has great markdown support, zero dependencies, and clean developer experience. It is also scalable, extensible and comes with a dedicated [catalog of themes](https://www.getzola.org/themes/).

Originally published [here](https://www.0xshapeshifter.dev/workshop/zola-intro/).

Build a blog with Zola in 15 minutes

Slowly looking for a purpose-driven team/initiative to commit to