Kevin Marsh is a web developer from Toledo, OH with a focus on simplicity and usability, an eye for design, and insatiable curiosity. History

As I was finishing up this refresh I decided to peek into and see what it looked like some time ago. It brought back a lot of memories! No such much the content (because, there isn’t much of it) but what was around it reminded me about the specifics of the tech which brought back more nostalgia than I expected.

I wonder if I should pull the content from those old posts and include here? (Of course, with some editing of those embarassing teenage ones…)

Some random things that stuck out:


I registered in January of the year I graudated high school.


I don’t have any solid captures of the CSS (which is ironic, given it was the era when you bragged about your HTML and CSS validating…) but was using Movable Type and writing Markdown. 16 years ago.

Then (of course), MT was too much and I had to roll my own blog.

2006 Screenshot from 2006

The Georgia header and 11px Lucida Grande body copy layout emerges. I used this for a long time. I had a “moblog” on the sidebar, featuring photos I took on my Treo 650 that were automatically uploaded to Flickr. (It’s amazing those links still work to this day, even after Flickr was acquired.)

It was running on TextPattern, hosted on TextDrive. Two blasts from the pasts. I was one of the original VC200 backers.

I eventually migrated to Mephisto and was hosting it on SliceHost. More blasts from the pasts (and more 11px Lucida Grande.) That was such an amazing period of learning and growth for me, especially related to Ruby and Rails.


I was being snarky about a tech CEO responding to censorship on their platform. Sound similar? (Although, @nat handled youtube-dl much better on GitHub.) Screenshot from 2007


I migrated from Mephisto to Jekyll, which was way ahead of its time as far as static sites go, way before it had a clever name.


Switched to the more-or-less current layout which was originaly implemented in Pure CSS. Screenshot from 2014


I noticed some weird scrolling issues with Pure CSS and wanted to try Tailwind CSS anyway so I undertook rewriting the CSS and freshening things up a bit:

There’s way more I want to do and way more I want to share, but this’ll be Good Enoughâ„¢ for now.

Apple Watch Colors

While I wish Apple Watch faces supported more customization, I really like the ability to change the colors. My standard is the Modular face with a color I select each morning that matches my shirt color. Really. To make that a little easier (and mostly because I was curious and couldn’t find this list anywhere) I collated the Apple Watch face colors and created the reference below:

Color NameHex Value
Light Orange#FF9500
Flash Light#F7EC00
Light Blue#6AC5DD
Royal Blue#63AEEE
Mist Blue#B3B8A7
Blue Cobalt#477E9D
Dark Teal#357393
Denim Blue#5B83A8
Midnight Blue#6084BF
Ocean Blue#7388C7
Ultra Violet#7157BE
Pink Sand#FFC2A9
Light Pink#F4B0AA
Vintage Rose#F4ACA5
Electric Pink#FF4E51
Rose Red#B92946
Antique White#D4B694
Soft White#DDD1BB
Dark Olive#8C8C76

Values were taken from screenshots of the Modular watch face on watchOS 5.0, AirDropped into Preview on a Mac with Digital Color Meter with Display native values selected. The hour/minute separator was sampled around the same location for every color.

I’ve often thought there wasn’t much variation between some of the shades on the Apple Watch. It was surprsing to me how distinctive some of the colors looked on my desktop display (a Dell P2715Q). I suspect it has more to do with seeing all the colors next to each other and not a deficiency in the Apple Watch’s OLED screen’s color rendition.


After its 0.24.1 release a week ago I decided to give Crystal a whirl. It’s been around since 2014 but is gaining traction.

I started my programming journey hacking on PHP in 2001 and grew into a developer with Ruby and its clean syntax. I’ve dabbled in Go but didn’t care for the syntax. I’ve dabbled in Elixir but had a hard time getting my app deployed with the right Erlang/OTP dependencies. Crystal ticks most of the boxes I care about:

  • Clean, familiar syntax
  • Fast!
  • Easy compilation to a single, easily-deployable binary
  • Modern standard library
  • Nice documentation

As its slogan says: “Fast as C, slick as Ruby.”

It also has a mature Sinatra-like web mini-framework called Kemal and an incubating-by-Rails-consultancy-juggernaut-Thoughtbot framework called Lucky which is shaping up nicely.

Getting Started

Installing Crystal on Mac is pretty easy with Homebrew: brew install crystal-lang.

Here’s a simple Hello World app:

puts "Hello World"

Run with crystal run or build a binary with crystal build

The syntax is identical to Ruby in most simple cases, but it’s not Ruby. For example, it can have types:

class Person
  def initialize(name : String)
    @name = name
    @age = 0

  def name

  def age

kevin ="Kevin") #=> "Kevin"

Sinatra vs. Kemal

I coded up a quick Sinatra “Hello World” app (which I can do mostly from memory) and a similar one in Kemal to give you a flavor of what it’s like to get started in Crystal.


require "sinatra"

get "/" do
  "Hello World!"

Now let’s run and benchmark it:

% RACK_ENV=production ruby sinatra.rb # run
% wrk -c16 -t16 -d30s http://localhost:4567/ # benchmark
Running 30s test @ http://localhost:4567/
  16 threads and 16 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency     6.41ms    7.87ms 178.16ms   91.30%
    Req/Sec   177.17     38.21   303.00     71.07%
  63540 requests in 30.09s, 11.21MB read
Requests/sec:   2111.50
Transfer/sec:    381.50KB


require "kemal"

get "/" do
  "Hello World!"

(Looks familiar, eh?) Let’s (compile!), run, and benchmark:

% crystal build --release # compile
% ./kemal # run
% wrk -c16 -t16 -d30s http://localhost:3000/ # benchmark
Running 30s test @ http://localhost:3000/
  16 threads and 16 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency     2.69ms    9.52ms 223.64ms   94.47%
    Req/Sec     1.34k   291.21     1.89k    71.22%
  639215 requests in 30.04s, 73.76MB read
Requests/sec:  21280.90
Transfer/sec:      2.46MB

About an order-of-magnitude faster! (Don’t you just love a good microbenchmark?) Plus we didn’t have to sacrifice any of the clean, familiar syntax of Ruby.

Crystal in Crystal

As I dove deeper, I learned Crystal is (mostly) implemented in Crystal, especially its standard library. (Kind of like Rubinius, remember that?) And its a modern one with built-in JSON parsing and generation support and a nice HTTP client, for example.

Since things are just ramping up the barrier of entry to contributing to Crystal and its fledgling libraries is pretty low. Especially since you don’t have to write C to contribute.

Growing Crystal

I’m skeptical about Crystal’s long term future, and probably won’t use it for any client apps at the moment, but I am digging into it for side projects and starting to advocate for it in small areas where is makes sense in the hopes that it may one day get the support it needs to grow.