Hugo Baldwin

90sleep - a sleep cycle calculator

2025-10-30T00:00:00+00:00

I've launched a new project: 90sleep.com - a sleep cycle calculator to help you figure out the best times to sleep and wake.

I was inspired by an old sleep calculator that's no longer available. The original app worked by calculating sleep cycles between now and your targeted wake time, helping you wake during the shallow phase of your sleep rather than in the middle of a deep sleep cycle. I rebuilt it as 90sleep.

The science is straightforward: sleep cycles are roughly 90 minutes each, and an assumption is made that it takes approximately ~14 minutes to fall asleep. The calculator helps you find optimal bedtimes and wake times based on this rhythm.

There are two modes: "I need to wake up at..." which calculates the closest shallow sleep phase before your desired wake-up time, and "I'm going to bed now" which I see as a sort of emergency mode when I've stayed up farrrrr to late yet still need to be semi-functional in a few hours. This displays the optimal wake times from now.

The site is a static site, generated using Python and Jinja2 templates. It's a similar approach to what I use for this blog (Pelican), but I've written a much simpler custom generator for this project. There's no server-side logic needed - the entire site is generated at build time.

For styling, I'm using Tailwind CSS with a custom colour palette (dark background with warm amber accents) loosely inspired by Dieter Rams. The interactive calculator itself is vanilla JavaScript - no frameworks needed for something this straightforward. I'm also self-hosting the Inter font family to keep things performant.

The build process is handled by a Python script that renders the Jinja2 templates and then the Tailwind CSS CLI minifies the CSS. The site barely needs it given that it's a single-page app, but it keeps it consisent with a bunch of other static sites I run and that makes working on it easier.

The site is deployed to Netlify, which handles the build and hosting automatically whenever I push to GitHub. I've integrated Plausible Analytics for privacy-respecting visitor analytics (no cookies, no tracking pixels).

90sleep works well, but I'm keen to improve the search ranking and have a few feature ideas in the pipeline. If you use it and have suggestions, feel free to reach out!

Introducing Remotely.nz

2024-07-17T00:00:00+01:00

I've launched a new project: Remotely.nz - a job board for genuinely remote work in New Zealand.

My story is straightforward. I fell in love with New Plymouth and want to settle here. It's a beautiful place - good waves, good coffee, stunning landscape - but let's face it, it's no tech hub. My search for a truly remote job in New Zealand opened my eyes to how broken the current job market is for remote workers here.

The frustrations are real. You think you've found the dream job on Seek, only to discover it's "hybrid" - requiring you to warm a seat in Grafton, Ponsonby, or a Wellington CBD office three days a week. That's not remote. Or you find a job listing that says "work from home" but it's usually just a synonym for hybrid. There's also the problem that most international remote job boards are heavily skewed towards the US and EU markets. RemoteOK has thousands of jobs, but very few are suitable for someone based in New Zealand.

And then there's Seek itself. It doesn't even have a remote category!

Remotely.nz cuts through all that noise. It aggregates job listings from multiple sources and filters them to surface genuine remote opportunities that actually work for kiwis. The site is built using Python with Jinja2 templates, deployed to Netlify, and automatically updated on a daily basis.

We're just getting started and I'm keen to work with recruiters and companies interested in featuring their remote positions. The vision is simple: New Zealand has amazing locations outside the big cities - whether you're looking for a place to raise a family, chase better waves, or just escape the concrete jungle. Your dream job shouldn't dictate your postcode.

Check out Remotely.nz and let me know what you think. If you're a recruiter or company with genuinely remote roles that suit New Zealand workers, I'd love to chat about getting your positions featured. Or if you've got feedback or ideas, drop me a message.

You can also join the community on Telegram or follow us on X for updates and discussions about remote work in New Zealand.

I've launched BuyVsRent.co.uk

2024-07-03T00:00:00+01:00

I've launched BuyVsRent.co.uk, a simple calculator to help you figure out whether buying or renting makes more financial sense.

The motivation behind this came from a pretty simple problem: there are a lot of property calculators out there, but most of them are either incomplete, misleading or don't give much flexibility in the investment comparisons. When I was trying to work through the numbers myself, I realised I needed something that actually accounted for investment returns on the money I'd save by renting. It felt weird that most calculators just ignored this entirely - if you're not buying a house, you're presumably investing that down payment somewhere.

So I built this calculator to do a proper year-by-year financial simulation. You input your local market data - house prices, rental costs, mortgage rates, property taxes, that sort of thing - and it compares what your net worth would look like over the course of the mortgage term if you bought versus if you rented. The clever bit is that it assumes any monthly difference between buying and renting costs gets invested, and it tracks those investment returns alongside your home equity. It also includes real investment options: Bitcoin, Ethereum, stocks, bonds, and gold with live data where available.

The calculator comes pre-configured with market defaults for the UK and New Zealand, pulling data from official sources like the UK Land Registry and NZ's MBIE. But you can override every single input if you want to model your own scenario. The results include an interactive chart showing wealth accumulation over time, so you can actually see when one option becomes financially superior to the other.

On the technical side, it's a lightweight static site built with Python and Jinja2, vanilla JavaScript for the calculations and Tailwind CSS for the styling. No backend required - everything runs in the browser and builds to a flat set of files that deploy to Netlify.

If you're thinking about property decisions - whether you're in the UK, New Zealand, or anywhere else - check it out and plug in your own numbers. I'd genuinely love to hear if it helps clarify things, or if you spot anything that could be better. You can reach me on Telegram or X.

Rental yield calculator

2023-02-27T00:00:00+00:00

I put a new project online: rentalyieldcalculator.co.uk. It's a simple tool to help mortgage lenders, letting agents, landlords (or potential landlords!) calculate their annual rental yield.

There are many yield calculators online already but this one is mine :D and it's conveniently located at a memorable UK domain name.

This is the first single page application I've created. It's also the first form I've written which doesn't POST to a server. The auto-calculate functionality was implemented using the magnificent Hyperscript. It reminds me of Jinja in the best of ways. I love the readability - people constantly forget that programming languages are created for humans first, then computers. Despite being written only once, programs tend to be refactored many times over, so language readability counts!

I originally intended to write it in React, but the thought flashed into my head "I bet this'd be simpler and easier using Intercooler!" It turns out Intercooler has been superceded by HTMX and (as far as I can tell) those talented people went on to create Hyperscript.

This is now also the fourth website I've published using Netlify - it's just that fast and easy to use! The sites almost all work via different mechanisms:

hugobaldwin.com and htbdevelopment.com are both Pelican static sites;
a page predicting the best day/time to go swimming in Torquay - it's a Python script which calls weather and tidal APIs at buildtime then generates an HTML file;
rental yield calculator - as described above, it's more or less a single page JS app.

I'm currently working on improving the search ranking of the site and also have a few other features planned.

Weekly routine changes

2022-09-02T00:00:00+01:00

I recently made four weekly routine changes all at the same time. This is rare for me - the last comparable change I made would be in June 2019 when I decided (and started) to lift consistently three days a week.

Three weeks ago I started swiming in the sea at 6pm on workout days;
A week ago I moved my 3x weekly weightlifting from 7pm to 5:30am;
I stopped drinking coffee (usually 2 cups over the course of a day);
I started drinking genmai-cha green tea (3-4x 400ml per day).

I've noticed the following benefits:

Working out in the evening, my motivation was generally low, with a nagging thought of "I'm tired, after this I'm going to get a shower and go to bed". Working out in the morning, I want to complete the workout, have breakfast and start the day!

No coffee / greatly reduced caffeine intake has meant no more anxiety, jitter, irritability or heart palpitations. Also, no more coffee sweat - yuck! I had mild headaches for a few days after dropping coffee but no more.

I bought a 400ml double-walled glass bottle from Amazon which I fill up before starting my workout, then drink and re-fill as needed from then onwards until I finish work at the of the day. The bottle being glass was important for me, as it allows me to see how much tea is left and acts as a constant reminder to drink - I previously had a problem staying sufficiently hydrated during the day.

I feel calmer, more energy, more focused than previously and appreciate the ongoing mental focus throughout the day rather than the spikes and slumps I'd get from coffee.

Physical recovery time has improved, although I'm unsure if that's from moving workouts to the morning, Theanine from the green tea or the shock to the body from swimming in the sea.

Finally, I used to rise at 8am or later and wanted to rise earlier for a long time now but failed to make it happen. This combination of changes seems to have helped it stick.

How to Refactor Code

2021-01-21T00:00:00+00:00

Seems obvious, right? You just edit it until it works the way you want it to. Not so fast. Reckless code changes will turn your project into a big ball of mud before you know it. Done in the right way you'll experience less frustration and fewer crises.

While you may write code as a developer, your main task is not writing code: it's removing ambiguity and mitigating project risks.

If you're working on a personal project or in a small startup this is not for you. This is written for the developers working in medium to large teams on mature codebases.

Small commits, named well

Keep your commits small and related to a single piece of functionality. This allows them to be easily reverted later if necessary.

Give your commits a descriptive summary - one which will help another developer to find the commit which introduced a particular feature (or bug!).

Bad:

"TAG-789"
"added some more code"
"addressed merge request comments"

Good:

"Split duplicated image analysis code out into its own function"
"Added GET param to QR code image URL to avoid cache"

Small merge requests

Where possible merge requests should be kept small. The more lines of code touched in the MR, the more likely it is:

to make your colleagues reluctant to review your code (especially since they're often under no obligation to do so)
for you to introduce bugs into the codebase (there's a direct relationship between line count and bug count)
for your reviewers to get fatigued and miss things

Sometimes you might be updating a library and you might have to create a huge merge request. That's ok - it's an exception. The rule is, keep your MRs small.

Incremental improvements

Suppose the team has identified the use of some particular pattern is, in fact, an anti-pattern. Unless you've been given the greenlight by your tech lead or dev team manager, do not go and strip out every occurrence of that pattern! Doing so introduces risk to the project. Instead, first raise a ticket to remove the offending pattern from the codebase. Then during the course of normal (unrelated) development:

if you're touching an offending pattern, re-factor it
if you're touching a function containing an offending pattern, re-factor it
if you're touching a file containing an offending pattern but it's unrelated to the code at hand, add a # TODO: refactor in [ticket number] comment

With any luck there'll be few to no occurrences left by the time the ticket is made priority.

Never write code without a ticket

Writing code is easy. Writing good tickets is hard. However that ticket is there to protect you.

Your colleague has a brilliant one-liner which makes the feature you're working on even better? Tell them to raise a ticket.
The tech lead asks you what it'll take to implement X or Y feature? You reply with 2 * (your best estimate). Perhaps offer to raise a ticket for them if one doesn't exist.

Including code which falls outside the scope of your ticket is scope screep. Every new line of code increases the probability of new bugs and therefore project risk. Additional code requires additional testing which delays the completion of the feature. Delays add pressure to everyone in the team.

So play it safe: ensure the code you're working on is part of a ticket and within scope.

A Gherkin styleguide

2021-01-20T00:00:00+00:00

Few, if any websites make useful recommendations about how to phrase Gherkin steps, so allow me to make some suggestions in the hope they will make life simpler.

Given steps establish state

Given steps describe a current, present, extant state of the test environment (I use the term loosely) before some (to be tested) action is performed.

The fact that your Given step definition likely creates that state in code behind the scenes is irrelevant.

Given steps must be in past or present tense
Given steps must not be in the future tense
Given steps must not contain action. That's the job of When.

Bad:

Given I populate the database
Given I have logged in as a user
Given the welcome banner has been displayed

Good:

Given the database is populated
Given I am logged in as a user
Given the welcome banner is displayed

In the latter of each of the two examples "Given the welcome banner has been displayed" is ambiguous - is it still being displayed, or was it simply displayed at some point in the past? Use the second example "Given the welcome banner is displayed", because it's unambiguous.

When steps perform an action

When steps should not discuss state. That's the job of Given and Then.
When steps should be in present tense

When I make a transaction of £100
When I flush the db connection
When I load https://google.com/

Then steps make assertions about state

Then steps do not talk about what will, should or may be, but what is (or is not). It's hard to make meaningful assertions about human intention ("will"), let alone software written by humans.

Then steps must be in present tense
Then steps must make an assertion

Bad:

Then I will be emailed a receipt
Then I will see the user login page
Then the search input field will be displayed

Good:

Then my inbox contains an email receipt
Then the user login page is displayed
Then the search input field is displayed

Your inbox either contains the expected email receipt or it does not. Yes/No, True/False. It's easy to test or make assertions about.

Last but not least, only Then step definitions may contain code assertions. You might think that's obvious and uncontroversial, but I've seen Given and When step definitions containing them.

In summary

Given steps establish state;

When steps perform an action;

Then steps make assertions about state.

Here's a minimal but complete example:

Given I am logged in as a user
When I load https://google.com/
Then the search input field is displayed

Eliminate abiguity. Favour simplicity. Never use more words if it can be adequately expressed with fewer.

The ultimate AeroPress technique

2017-03-16T00:00:00+00:00

Having made countless cups of AeroPress'd coffee (mostly at work), I've finally arrived at the perfect cuppa.

Boil the jug. Yup, boil. You'll see why in a moment.
Pour boiling water into your coffee cup. If you take milk in your coffee leave room for milk. Otherwise fill it up.
Grind coffee / put ground coffee in an inverted AeroPress.
Fill AeroPress with hot water from cup. Your cup is now hot and the water has cooled to the perfect temperature.
Stir coffee in AeroPress.
Screw filter & cap onto AeroPress, leave for a minute or two.
Pour milk into cup.
Place AeroPress right way up on the cup.
Slowly plunge the coffee into the cup.
Pop out used coffee grounds, rinse rubber seal, enjoy coffee.

This way the water can be used straight after boiling without waiting for it to cool to 85-90°, and you can warm your cup at the same time without wasting water.

New project: CourseMonger.com

2017-03-13T00:00:00+00:00

So! I have a new project underway, CourseMonger.com.

Unlike many solutions, this one started with a problem. My partner teaches parenting courses, each comprised of multiple workshops. Each workshop can be at a different price and vary in number of places available. Any prospective system would also need to provide a reservation system whereby a place is reserved for say, 8 minutes while a student completes her booking.

Eventbrite provides registration-locking, but the Eventbrite model is based on events, many people at a specific location and time at perhaps a few different pricepoints (tickets). Like a concert or sports event. It lacks the ability to setup multiple classes per event or have per-class availability & pricing.

Wouldn't it be nice if there was something designed specifically for the needs of small classes? For parenting workshops, yoga classes, dance practice, martial arts training, etc?

CourseMonger allows you to create courses comprised of multiple classes. Each class can have its own title and optional description, spaces available, price and start and finish times.

Once created, your course can be distributed to students as a single course registration page listing all the classes you run.

Give it a try! Email me directly with suggested features or bugs using support@coursemonger.com, I'd love to hear from you.

How to create many-to-many relationships with associated properties in SQLAlchemy

2016-06-05T00:00:00+01:00

I once had a scenario where one business could be managed by multiple users, and each user could manage multiple businesses. To further complicate matters, only one user could be the Administrator of a business, which should ideally also be represented by the relationship.

Finding out how to represent that relationship was tricky as I couldn't find it in the SQLAlchemy docs, and StackOverflow was a mixed bag. This is what I pieced together:

from datetime import datetime as dt
from app import db
from sqlalchemy import Table, Column, Boolean, DateTime, Integer, \
    SmallInteger, String, ForeignKey
from sqlalchemy.orm import relationship
from app import constants


# Establish many-to-many relationship between users and (business) businesses
class UserBusiness(db.Model):
    __tablename__ = 'userbusiness'
    user_id       = Column(Integer, ForeignKey('users.id'), primary_key=True)
    business_id   = Column(Integer, ForeignKey('businesses.id'),
                           primary_key=True)
    administrator = Column(Boolean, default=False)
    business      = relationship('Business', backref='users')
    user          = relationship('User', backref='businesses')


class User(db.Model):
    __tablename__ = 'users'
    id            = Column(Integer, primary_key=True)
    email         = Column(String(256), unique=True)
    name          = Column(String(128))
    password      = Column(String(256))
    last_auth     = Column(DateTime, default=dt.utcnow)
    status        = Column(SmallInteger, default=constants.NEW)
    # timestamps
    update_date   = Column(DateTime, default=dt.utcnow, onupdate=dt.utcnow)
    insert_date   = Column(DateTime, default=dt.utcnow)

    def __init__(self, email=None, name=None, password=None):
        self.email = email
        self.name = name
        self.password = password


class Business(db.Model):
    __tablename__ = 'businesses'
    id            = Column(Integer, primary_key=True)
    name          = Column(String(256))
    status        = Column(SmallInteger, default=constants.NEW)
    # timestamps
    update_date   = Column(DateTime, default=dt.utcnow, onupdate=dt.utcnow)
    insert_date   = Column(DateTime, default=dt.utcnow)

    def __init__(self, name=None):
        self.name = name

In a Flask application, this would be contained your models.py file. Python's __repr()__ and other common functions omitted for clarity.

To record a new User-Business relationship, first create the UserBusiness relationship, then add in the User and Business objects (if this were Flask, this'd likely be in views.py):

ub = UserBusiness(user=g.user, administrator=True)
ub.business = Business(name='Acme Widgets Ltd')
db.session.add(ub)
db.session.commit()

To get a list of Businesses a user manages, you can do something like the following:

businesses = [ub.business for ub in g.user.businesses]

ub here represents the UserBusiness relation. You could then extend it to only get businesses which the user is an administrator of:

businesses = [ub.business for ub in g.user.businesses if ub.administrator]

It's all beautifully simple once you've done it successfully once or twice...

What's your capacity to hustle?

2016-05-29T00:00:00+01:00

This gem turned up in the Ribbonfarm post Stone-Soup for the Capitalist’s Soul:

Your rights to your wealth do not extend beyond your understanding of it.
You are fair game for hustlers who understand your wealth better than you do.
The role of the state is to limit the violence with which you can be hustled.
If you are poor you have the right to hustle the rich within certain limits.

It's a take on the old stone-soup fable in which a hungry soldier returning from war asks an old woman for food and is denied. He then tells her he can make a magnificent soup using only a stone and hot water. The old woman is curious and asks him to show her.

Between tastes, he tells the woman the soup is coming along nicely; "however it would be even better if only they had a little <insert ingredient>". In this way he persuades her to part with more ingredients until he has prepared a great meal for them both.

Ultimately the soldier leaves and the old woman realises it's just a normal stone.

Venkatesh doesn't tell you what to do with his writing. It's probably best left as an exercise for the reader. Gotta have some skin in the game after all.

Installing Apache Cordova on BunsenLabs Linux

2016-02-27T00:00:00+00:00

Installing Cordova wasn't straightforward, so I wrote up what worked for me.

First install Nodejs and create a symlink because it gets installed as nodejs rather than node.

curl -sL https://deb.nodesource.com/setup_5.x | sudo -E bash -
sudo apt-get install -y nodejs
sudo ln -s /usr/bin/nodejs /usr/bin/node

NPM is thankfully in the debian repos:

sudo apt-get install npm
sudo apt-get install -y build-essential

Install Cordova using NPM and create your first project:

sudo npm install -g cordova

cordova create MyProject
cd MyProject

platform add browser
platform add android

The cordova run browser command requires google-chrome so I installed chromium then symlinked google-chrome to it (you can skip this step if you use Chrome):

sudo apt-get install chromium
sudo ln -s /usr/bin/chromium /usr/bin/google-chrome
cordova run browser

Ta-da! You can now see your project running in the browser, such as it is.

Install the Android Stand-Alone SDK tools, then set the ANDROID_HOME environment variable and add the Android tools to your PATH:

nano ~/.bash_profile
export ANDROID_HOME=~/bin/android-sdk-linux
export PATH=$PATH:$ANDROID_HOME/tools
source ~/.bash_profile

While this article was helpful I was ultimately unable to make the new environment variables persist over reboots, no matter which file I added them to (.bash_profile, .profile, .pam_environment, etc).

Now try and build your new app:

cordova build

If you get an error about being unable to run java -version, you may need to install the JDK and add the JAVA_HOME environment variable:

sudo apt-get install default-jdk
export JAVA_HOME=/path/to/jvm/

If you get the following error:

:CordovaLib:processDebugResources FAILED

FAILURE: Build failed with an exception.

* What went wrong:
Execution failed for task ':CordovaLib:processDebugResources'.
> A problem occurred starting process 'command '/home/windlab/bin/android-sdk-linux/build-tools/23.0.2/aapt''

* Try:
Run with --stacktrace option to get the stack trace. Run with --info or --debug option to get more log output.

BUILD FAILED

Total time: 2.785 secs
ERROR building one of the platforms: Error code 1 for command: /home/windlab/projects/AlarmClock/platforms/android/gradlew with args: cdvBuildDebug,-b,/home/windlab/projects/AlarmClock/platforms/android/build.gradle,-Dorg.gradle.daemon=true,-Pandroid.useDeprecatedNdk=true
You may not have the required environment or OS to build this project
Error: Error code 1 for command: /home/windlab/projects/AlarmClock/platforms/android/gradlew with args: cdvBuildDebug,-b,/home/windlab/projects/AlarmClock/platforms/android/build.gradle,-Dorg.gradle.daemon=true,-Pandroid.useDeprecatedNdk=true

It's because you're trying to run a 32bit file on 64bit system. Thanks Abdelraman Elkady!

sudo apt-get install lib32stdc++6
sudo apt-get install lib32z1

Finally, run the following command to display your new app in the Android emulator (if you haven't created one already the error surprisingly gives useful instructions):

cordova emulate android

Calling the Top

2014-11-12T22:41:00+00:00

Some time mid-2013 I was reading through rpietila's posts on the bitcointalk.org forums and came across the theory that you could "call the top" of a bubble simply by selling if the price doubles in 7 days.

Unfortunately, he's got 4.7k-odd posts now, so the exact post has eluded me so far.

While the old trope "past performance doesn't indicate future results" always applies, there's no harm in being prepared to take advantage of an identified pattern should it manifest again.

For an example from the most recent doubling-in-7-days, see this chart of the Nov 2013 run up to Dec 31st peak, where 7-day price doublings can be seen twice:

Bitcoin charts link

In light of the recent upward price movement (THIS IS GENTLEMEN), the topic seemed apposite, so I whipped up a script to test the theory:

# if bitcoin price on Bitstamp doubles within a 7-day timeframe, sell

from datetime import datetime as dt
from datetime import timedelta
import hashlib
import hmac
import json
from time import sleep
import requests


URL = 'https://www.bitstamp.net/api/'
seven_day_history = []

CLIENT_ID = 0
API_KEY = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
API_SECRET = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'


def get_nonce():
    return int((dt.utcnow() - dt(1970, 1, 1)).total_seconds())


def make_request(path=None, data=None):
    try:
        r = requests.post(URL+path, data)
        r.raise_for_status()
        return json.loads(r.text)
    except Exception as e:
        print e

def make_private_request(path=None, parameters=None):
    nonce = get_nonce()
    message = '{}{}{}'.format(nonce, CLIENT_ID, API_KEY)
    signature = hmac.new(
        API_SECRET, msg=message, digestmod=hashlib.sha256).hexdigest().upper()

    data = {'key': API_KEY, 'signature': signature, 'nonce': nonce}
    if parameters: data.update(parameters)

    return make_request(path=path, data=data)


while 1:
    ticker = make_request(path='ticker/')
    now = dt.utcnow()

    # append time stamp and price of bitcoin to list
    seven_day_history.append((now, float(ticker['bid'])))

    # remove items older than 7 days
    for i in seven_day_history:
        if i[0] < now-timedelta(days=7):
            seven_day_history.remove(i)

    d1_price = seven_day_history[0][1]
    d7_price = seven_day_history[-1][1]

    # sell all available bitcoin if price doubled in last 7 days
    if d7_price >= d1_price*2:

        balance = make_private_request(path='balance/')
        xbt_available = balance['btc_available']

        # place limit order at price of highest bid
        sell = make_private_request(path='sell/',
                                    parameters={'amount': xbt_available,
                                                'price': d7_price})

        print '{}: Placed order id {} to sell {} XBT at {} each.'.format(
            sell['datetime'], sell['id'], sell['amount'], sell['price'])

    # sleep for 12 hours
    sleep(43200)

View on Github

To use this, you will need a funded Bitstamp account with an API key setup allowing the script to query balance and place sell orders. Suggested improvements would include:

increasing the price checking frequency - sleep(21600) would give you a 6hr resolution
message logging / email sending
replace scheduling by running script as cron job, with celery, etc

Mandatory disclaimer: The code is licensed under the MIT license and does not claim to be fit for any purpose.

blogging with Pelican and Github pages

2014-11-12T21:40:00+00:00

Hey! Welcome to my new blog.

So, when it came to setting up a blog again, I didn't want to go the old route to Livejournal / Blogger / Tumblr. Too much Y2K, Google, and teenage girl angst, respectively. Svbtle & Ghost cost money, and Medium's focus is on the platform, not you. That's when I remembered Github pages allows you to setup a free static site.

First create a new Github pages repo called username.github.io, where username is your Github username. Create a new folder locally to store the site files (I like to keep website files tidy in /var/www/):

mkdir /var/www/username.github.io
cd /var/www/username.github.io
git clone https://github.com/username/username.github.io

To save time on building a site, I first tried using Jekyll, but found the instructions unclear and the setup seemed needlessly complex. Apart from that, why is it so difficult to install anything Node related on Debian (though a friend has the same issue on Fedora, so maybe it's a Node thing)?

Then I found Pelican, which allows you to write content using markdown and renders site templates into HTML using Jinja. It's also much easier to install and get running!

pip install pelican

Site content goes in a content/ folder inside the pelican install directory, and individual pages start with simple metadata:

Title: My super title
Date: 2010-12-03 10:20
Modified: 2010-12-05 19:30
Category: Python
Tags: pelican, publishing
Slug: my-super-post
Authors: Alexis Metaireau, Conan Doyle
Summary: Short version for index and feeds

This is the content of my super blog post.

To preview the site locally, run a Python web server, then check localhost:8000:

cd output
python -m SimpleHTTPServer

To publish your content live, back in the main site directory run the following commands:

pelican
cd output
git add --all
git commit -m "my first commit"
git push

Of course, there's lots of other things you can do, like changing or customising the default theme. Read the docs here (wish more projects used read the docs!