Back to blog

Hello World: A Fresh Start

3 min read
meta announcements

Welcome to my freshly rebuilt website! 🌲

I wanted to create a space that feels like home — somewhere I can share what I’m learning, explore ideas, and hopefully help others along the way. This site is my digital garden, a place that grows and evolves over time.

What You’ll Find Here

This site has three main sections:

  1. Blog — Long-form articles like this one, diving deep into topics
  2. TIL (Today I Learned) — Quick notes from daily discoveries
  3. Projects — Things I’ve built and am working on

Great question! A digital garden is less about polished, final articles and more about learning in public. Some notes might be rough. Some ideas might evolve. That’s the point — it’s a living collection of knowledge, not a curated highlight reel.

Features Demo

Let me show you some of the interactive elements you’ll encounter:

The Curious Reader

Throughout the site, you’ll see callouts from a curious character who represents you, the reader. They ask the questions you might be thinking:

Exactly! It makes the content more conversational and helps address common points of confusion.

Callouts for Important Information

Code with Annotations

One of my favorite features is annotated code blocks. Here’s an example:

rust greeting.rs 
fn main() {❶
  let greeting = "Hello, world!";❷
  println!("{}", greeting);❸
}
❶

Every Rust program starts execution in a main function. Unlike some languages, Rust’s main doesn’t take arguments or return a value by default (though you can configure it to do both).

❷

The let keyword creates a new variable binding. Rust infers that greeting is a &str (string slice) from the literal we’re assigning. Variables are immutable by default — you’d need let mut to make it changeable.

❸

println! is a macro (note the !), not a regular function. The {} is a placeholder that gets replaced with the value of greeting. Macros in Rust can do things functions can’t, like accept variable numbers of arguments.

Macros can do compile-time string formatting, type checking, and accept variable arguments — things that regular functions in Rust can’t do as elegantly. The println! macro is optimized at compile time, so there’s no runtime overhead for the formatting.

What’s Next?

I’ll be posting regularly about:

  • Rust and systems programming
  • Functional programming concepts
  • Developer tools and productivity
  • Interesting problems I encounter

Subscribe to the newsletter to get notified when I publish something new. No spam, just learning together.

See you in the next post! 🌿