Posts on jonathanchu.is

Introducing magit-gh

Jonathan Chu — Sun, 08 Feb 2026 00:00:00 -0500

After recently releasing magit-git-toolbelt, a Transient interface for git-toolbelt in magit, I’m happy to share another Magit extension I’ve been working on – magit-gh, an Emacs package that integrates the GitHub CLI (gh) into Magit. Similar to my former package, it provides a Transient menu interface to list, checkout, and view pull requests directly from Emacs without leaving your workflow.

Why I wrote this Link to heading

If you work with pull requests on GitHub every day, you know the git checkout dance: you’re deep in flow and in a Magit buffer, you need to check on a PR, so you switch to a browser, find the repo, navigate to the PR tab, and then maybe come back to checkout the branch in eshell or even your terminal. It’s a small context switch, but it adds up.

Forge has been the defacto and established solution for this and it’s a fantastic and comprehensive package for interacting with Git forges from within Magit – it has all the bells and whistles for this workflow. If you need deep integration – tracking issues, managing pull requests, reading and writing comments, all stored locally in a light database – Forge is the right tool. I would highly recommend Forge over this package if that is your use case.

magit-gh takes a different approach. It delegates to the GitHub CLI (gh) for all GitHub interaction, which means:

No local database – Forge maintains a local SQLite database via emacsql, which can be tricky to set up (compiling native modules, resolving binary availability issues). magit-gh stores nothing locally.
No token management – Forge requires a GitHub personal access token stored in your authinfo file (ideally encrypted with GPG). magit-gh piggybacks on gh auth login, which you have already configured from authenticating the first time.
Minimal dependencies – just Magit, Transient, and the gh CLI.

The trade-off is that magit-gh is far less featureful than Forge. It is intentionally a lightweight alternative for users who primarily want to list, checkout, and view pull requests without additional setup overhead.

Installation Link to heading

You’ll need the GitHub CLI installed and authenticated first:

# macOS
brew install gh

# Linux (Fedora / RHEL / CentOS)
sudo dnf install gh

# Then authenticate
gh auth login

Then install magit-gh from MELPA:

M-x package-install RET magit-gh RET

Or with use-package:

(use-package magit-gh
  :ensure t
  :after magit)

Usage Link to heading

From any Magit status buffer, press , to bring up the magit-gh Transient menu. You can also invoke it directly with M-x magit-gh. The menu is organized into Pull Request commands:

magit-gh
└── Pull Requests
    ├── l  List open PRs
    ├── c  Checkout PR
    └── v  View PR in browser

When you list open PRs (l), a dedicated buffer opens showing PR number, title, author, and branch name. From that buffer you can checkout a PR with RET or c, open it in your browser with v, refresh the list with g, or close the buffer with q.

If you don’t like the , key binding, you can set a custom one. Note that the variable must be set before the package loads so it needs to be in the init section:

(use-package magit-gh
  :ensure t
  :after magit
  :init
  (setq magit-gh-key ";")) ; Example setting key to ";" instead of the default ","

To increase the number of PRs fetched (default 30):

(use-package magit-gh
  :ensure t
  :after magit
  :custom
  (magit-gh-pr-limit 50))

What’s next Link to heading

Aside from bugs and visual improvements to the TUI, I would consider this package mostly feature complete. The current feature set is intentionally small, but I have plans to add support for listing closed/merged PRs, creating new PRs, viewing diffs and CI status, and eventually issue management – all through the gh CLI. You can track progress on the GitHub repo.

If you use Magit and the GitHub CLI, give magit-gh a try! It’s available on MELPA and the source is on GitHub. Contributions and feedback are always welcome! Hope this is useful!

Introducing magit-git-toolbelt

Jonathan Chu — Wed, 28 Jan 2026 00:00:00 -0500

I’ve been a long-time user of both Magit and git-toolbelt, a suite of useful git helper commands by Vincent Driessen (@nvie). Often times I find myself reaching for several commands constantly in my day-to-day workflow - things like cleaning up merged branches, listing recent branches, checking which local commits haven’t been pushed yet, and more. My two favorite ones are git cleanup and git delouse. I won’t go into details of what these do, but check it out for yourself to learn how it can fit in your own git workflow! These tools were extremely helpful in simplifying my own personal workflow and allowed me to get back actually writing code instead of doing git surgery – and sometimes unsuccessfully! The only friction was that I’d have to jump out of Magit and into a shell to run these commands…so I wrote a package to fix that!

magit-git-toolbelt is an Emacs package that integrates git-toolbelt commands directly into Magit through a Transient menu interface. If you’re already comfortable in Magit’s workflow, this should feel right at home.

What it does Link to heading

The package provides a Transient menu that organizes some select git-toolbelt commands into logical groups:

Commit Info - Display the initial commit, current branch SHA, and local (unpushed) commits
Branch Management - Cleanup merged branches, list recent/local/remote branches
Merge Status - Check which branches have been merged or remain unmerged
Diff & Inspection - Show modified and untracked files
Actions - Undo and quickly reverse the last commit

Screenshot Link to heading

Installation Link to heading

You’ll need git-toolbelt installed first, then you can install magit-git-toolbelt from MELPA:

M-x package-install RET magit-git-toolbelt RET

Or with use-package:

(use-package magit-git-toolbelt
  :ensure t
  :after magit)

Usage Link to heading

From any Magit status buffer, press \ to bring up the git-toolbelt Transient menu. You can also invoke it directly with M-x magit-git-toolbelt. From there, you get a submenu of all the available commands organized by category.

If you prefer a different keybinding instead of \, you can customize it before the package loads:

(use-package magit-git-toolbelt
  :ensure t
  :after magit
  :init
  (setq magit-git-toolbelt-key ".")) ; Example setting key to ".o" instead of the default "\"

Why Link to heading

The motivation for writing this wrapper package is simple - I wanted to stay in Magit. Every time I wanted to run a git-toolbelt helper command, I would have to break out of my Magit workflow and drop into eshell or terminal to run git cleanup, as an example of one of my favorite git-toolbelt helpers. It was a small context switch and minor inconvenience that added up over the course of a day, but now those commands are just a keypress away from the Magit status buffer.

I actually enjoyed writing this package – it was good to get back into a fully functional language and get my brain working a bit more than usual. Fun fact - git spinoff was directly inspired from Magit! My next goal for this package is to take better inventory of the tools in git toolbelt and analyze what functionality is already covered in Magit’s extensive featureset, and see what git helper commands I could expose in magit-git-toolbelt that truly offers novel functionality to Magit users.

If you use both Magit and git-toolbelt, give it a try and let me know what you think! The source is on GitHub and it’s available on MELPA.

Code Forensics on init.el

Jonathan Chu — Mon, 19 Jan 2026 18:40:09 -0500

I’ve always been interested in developer experience and understanding the metrics often used to measure this unique type of productivity. It’s extremely enticing to think that If I could change my tooling, gain insight through telemetry and other metrics, I could potentially “game” a better and more fullfilling developer experience overall - and ultimately over-achieve when typically I would just coast through. The experience I’m talking about improving is not so much solely about the 9-5 day job work, but more about the overarching craft of engineering. Whether you’re coding away on pet projects on nights and weekends, tinkering with editors or Linux distros, or learning new technologies and programming languages for work, the underlying takeaways and insights one could gain from these developer experience metrics would carry over to all tangible coding activities that we do.

A while back, I watched one of Adam Tornhill’s talks on YouTube and the idea of “Your Code as a Crime Scene”. This was around the time that I started dabbling with Clojure and when I found out he wrote a book of the same title that followed a tool he released online, written in Clojure - it was a perfect match of interests and technology for me. Cloning the repo and following the README, code-maat https://github.com/adamtornhill/code-maat was relatively easy to get up and running for baseline code analysis. The basic gist of this all is that you install the repo and run some jars over a git log that you save locally for static analysis. The GitHub page is well-documented but perhaps I will share my own notes (in the Notes section) for how I got it up and running at least.

I decided to run this against a personal (what feels like a lifelong or lifetime) endeavor, my emacs config, and was curious to see what the output was. What follows was some insights, however obvious some may be, but also insightful findings from the code-maat output.

Top-level numbers on my dotemacs https://github.com/jonathanchu/dotemacs repo. Over 11 years and 1,738 commits of config changes, visual UI and modeline tweaking, and transitions to org mode literate source blocks back to plain old elisp (and maybe a few more cycles of that dance over the years) ;)

Hotspots (Most Changed Files)

This highlights files with the highest change frequency. These are potential hostpost where bugs tend to cluster and where refactoring may have the highest impact. Since these are screenshots, the large red dot in the first quadrant is my init.el file.

Temporal Coupling is an interesting relationship insight into files and pairs of files.

What this shows is files that frequently change together in the same commits. High coupling (60%+) between unrelated files may indicate hidden dependencies. Low coupling between related files (like .el and .org) is expected and healthy. There were no surprises here other than being impressed at how well this worked on first analysis. For example, when my emacs-init.org changed, so did my emacs-init.el in an expected and coupled manner.

Code Complexity vs Change Frequency

I think this was the most interesting and valuable metric and visualization. This is the “hotspot” visualization from the book and files in the upper-right quadrant (large file AND frequently changed) are the highest priority for refactoring.

I took it a step further and put an overlay over the hotspot chart to better show the risk and complexity.

This chart shows the files plotted by complexity (LOC in this case) vs change frequency, with quadrants indicating refactoring priority.

Top-Right (Red): High complexity + High churn = Refactor now — these are your biggest risks
Top-Left (Orange): High complexity + Low churn = Consider refactoring — complex but stable
Bottom-Right (Yellow): Low complexity + High churn = Monitor — lots of changes but manageable
Bottom-Left (Green): Low complexity + Low churn = Leave alone — no action needed

All in all, this was a really neat and interesting tool to play around with, despite it being on a somewhat trivial, but active, repository. I am thinking of how I can leverage this in my day-to-day in a more automated way. In the meantime, if you want to try this out for yourself (go see code-maat) or just want to get your toes wet with static code analysis, I extracted the essential git commands for you to replicate this to a smaller degree. Give it a shot and see what insights you can gain!

Git Commands Reference

Hotspots - Most frequently changed files

git log --format=format: --name-only | grep -v '^$' | sort | uniq -c | sort -rn | head -20

Code Churn - Total lines added/removed per file

git log --numstat --format= | awk '{add[$3]+=$1; del[$3]+=$2} END {for(f in add) if(f) printf "%d\t%d\t%d\t%s\n", add[f]+del[f], add[f], del[f], f}' | sort -rn | head -20

Code Age - Last modification date per file

git ls-files | while read f; do echo "$(git log -1 --format='%ai' -- "$f") $f"; done | sort -r

Temporal Coupling - Files that change together

git log --format='%H' | head -200 | while read commit; do
  files=$(git diff-tree --no-commit-id --name-only -r $commit | sort)
  echo "$files" | while read f1; do
    echo "$files" | while read f2; do
      if [[ "$f1" < "$f2" ]]; then echo "$f1 <-> $f2"; fi
    done
  done
done | sort | uniq -c | sort -rn | head -20

Commit Frequency - Commits per day

git log --format='%as' | sort | uniq -c

Lines of Code - Current state

git ls-files '*.el' | xargs wc -l | sort -rn

Dark Mode Toggle for iTerm and Emacs

Jonathan Chu — Sun, 12 Jul 2020 00:00:00 -0400

For most of my life, I’ve always preferred a dark theme when it comes to coding whether I’m in Emacs or the terminal. Lately though, the past two years specifically, I’ve switched to a light theme for both Emacs and iTerm. I really don’t have a better rationale other than I feel like the lighter theme means it’s “work” time and helps me focus, whereas a dark theme would be more suitable if I was coding at night and wanted to save some eye strain from a full day of looking at a computer screen.

With that said, I’ve definitely utilized Mac OS X’s dark mode toggle and the one thing that has bothered me was the white glare of my Emacs and terminal when I was coding at night. I wrote up a series of scripts inspired by Anantha Kumaran’s excellent post on this exact issue called Dark Mode Toggle.

Now, I can type a single command in terminal and it would change to a dark theme in both Emacs and iTerm.

And here are the scripts that I wrangled together to achieve this:

Toggle to a dark Emacs theme:

Filename: emacs-dark-theme

#!/bin/sh
set -e

if pgrep Emacs > /dev/null; then
    emacsclient --eval "(load-theme 'doom-one t)" > /dev/null
fi

Toggle to a dark iTerm color scheme using AppleScript and iTerm’s Python API:

Filename: iterm2_dark_theme.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import iterm2

async def main(connection):
    # Get the color preset we'd like
    preset = await iterm2.ColorPreset.async_get(connection, "One Dark")
    profiles = await iterm2.PartialProfile.async_query(connection)
    for partial in profiles:
        # Fetch the full profile and then set the color preset in it
        profile = await partial.async_get_full_profile()
        await profile.async_set_color_preset(preset)

iterm2.run_until_complete(main)

Call the iTerm Python script via AppleScript:

Filename: iterm-dark-theme

tell application "iTerm2"
    launch API script named "iterm2_dark_theme.py"
end tell

I combine calling these scripts with one command like so:

Filename: dark-mode

#!/bin/sh
set -e

/bin/bash /Users/jonathan/projects/dotfiles/bin/emacs-dark-theme
osascript /Users/jonathan/projects/dotfiles/bin/iterm-dark-theme

And now this all can be ran with just:

$ dark-mode

The same workflow can be done for switching back to a light theme by creating a new set of these scripts and modifying to the light theme you want!

Thank you to Anantha Kumaran for this first post and all credit goes to him!

Happy (night) hacking!

Emacs, Notmuch, isync, and msmtp Setup

Jonathan Chu — Tue, 23 Jun 2020 00:00:00 -0400

I’ve been meaning to move my email management to Emacs for the past year and finally made the jump after see Mike Zamansky’s video on this (YouTube). Here are my notes on how I got this all setup and configured.

This is an opinionated setup based on Mac OS X and Fastmail. First, make sure you have Homebrew installed to install the packages needed.

Receiving email Link to heading

Notmuch requires email to be stored on your local filesystem and one message per file. We’ll be using isync for this.

$ brew install isync

http://isync.sourceforge.net/

You’ll need to start out with an initial config which you can copy directly to your home directory.

My .mbsyncrc file looks like this:

# First section: remote IMAP account
IMAPAccount fastmail
Host imap.fastmail.com
Port 993
User jonathanchu@fastmail.com
# For simplicity, this is how to read the password from another file.
# For better security you should use GPG https://gnupg.org/
PassCmd "cat ~/.mbsync-fastmail"
SSLType IMAPS
SSLVersions TLSv1.2

IMAPStore fastmail-remote
Account fastmail

# This section describes the local storage
MaildirStore fastmail-local
Path ~/Maildir/
Inbox ~/Maildir/INBOX
SubFolders Verbatim

# This section a "channel", a connection between remote and local
Channel fastmail
Master :fastmail-remote:
Slave :fastmail-local:
Patterns *
Expunge None
CopyArrivalDate yes
Sync All
Create Slave
SyncState *

The contents of .mbsync-fastmail contains my email password, which is probably not the best way to do store a password like this locally so I should fix this in the near future.

Once this is configured and saved in your home directory, you can then run run mbsync to pull your email down locally:

$ mbsync -a

Note, you’ll have to run this each time to retrieve new mail. I know some folks might elect to have this as a running cron job every x minutes - this can be entirely based on your preference and email workflow.

And finally, we just need to setup a search database for notmuch to work by running:

$ notmuch new

Viewing and writing email Link to heading

We’re going to use Notmuch, specifically in Emacs, to view our mail. First, you need to install Notmuch on your OS:

$ brew install notmuch

Once notmuch is installed, run the following command to setup notmuch. This will create a .notmuch-config in your home directory.

$ notmuch setup

When you have entered your email information, in your Emacs configuration, you can install notmuch-emacs by including the following:

(use-package notmuch
  :ensure t
  :defer t)

Then, you can run m-x notmuch-hello and you will be greeted with the notmuch starting screen.

Figure 1: m-x notmuch-hello

Figure 2: notmuch unread

Sending email Link to heading

Next, we’ll need to send our mail with something, so I chose msmtp because of how easy it was to configure.

$ brew install msmtp

The contents of my .msmtprc file looks like this:

defaults
auth on
protocol smtp
tls on

account fastmail
host smtp.fastmail.com
port 465
user jonathanchu@fastmail.com
passwordeval "cat ~/.mbsync-fastmail"
tls_starttls off
from jonathanchu@fastmail.com

account default : fastmail

Add this bit in your Emacs config:

(setq send-mail-function 'sendmail-send-it
      sendmail-program "/usr/local/bin/msmtp"
      mail-specify-envelope-from t
      message-sendmail-envelope-from 'header
      mail-envelope-from 'header)

This article will be updated as I refine my email process and work out the bugs, but at this point you should have working email with Notmuch in Emacs!

EmacsConf 2019 Magit Deep Dive

Jonathan Chu — Tue, 07 Apr 2020 00:00:00 -0400

I was fortunate enough to get to present at EmacsConf 2019 in November of last year and I wanted to share the content from my presentation:

And here’s the source for my org slides on GitHub:

https://github.com/jonathanchu/emacsconf-2019-magit-deep-dive

Getting Started with Emacs and Clojure on OS X

Jonathan Chu — Sat, 13 Jun 2015 00:00:00 -0400

I’ve been learning Clojure in my spare time and coming from a predominantly Python-focused career, I wanted to chronicle my experiences with learning Clojure and integrating it within my Emacs config.

This article will be geared towards beginners, like me, looking to get started with Clojure and Emacs on OS X.

Install Homebrew - http://brew.sh/

I won’t go into too much detail here, aside from providing the link where you can find all the resources on installing this. I highly recommend using Homebrew for your packaging needs on OS X. The one liner to install looks like this:

ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

We’ll be using Homebrew to install some of the necessary programs and libraries.

Install Homebrew Cask

Next, we’ll need to install Java, as Clojure runs on the Java Virtual Machine (JVM). You’ll need to install the Java Development Kit (JDK).

Java from Oracle

You can go to the Java website above to download it and install manually, but I prefer to let package managers do that for me. It is recommended to download at least version 6 of the JDK.

For this, we can install the JDK through Homebrew Cask, which we will need to install:

brew install caskroom/cask/brew-cask

Homebrew Cask is really useful for managing application installs. No more dragging to your Applications folder anymore!

Install Java

Now that we have Homebrew Cask installed, we can install the JDK by simply doing:

brew cask install java

This will pull the latest version of the JDK according to Homebrew Casks and install it on your machine. It should prompt you for your password to proceed with the install.

Install Leiningen

Leiningen is a user interface to the Clojure library that helps you automate projects and manage dependencies, while fully setting up lein and Clojure for you.

brew install leiningen

You now have Clojure installed!

Configure Emacs

This is mostly an optional step if you haven’t done this already. Make sure you have something like this in your Emacs config:

(add-to-list 'exec-path "/usr/local/bin")

If your Homebrew install is standard, this is where your binaries should be located. If not, adjust the path as necessary.

Install Emacs packages cider

m-x package-install RET cider

Optionally, if you want to do 4clojure problems in Emacs, also install 4clojure.el:

m-x package-install RET 4clojure

Add a profiles.clj

In your home directory, create a new profiles.clj in ~/.lein/ and put this barebones config to start with:

{:user {:plugins [[cider/cider-nrepl "0.9.0-SNAPSHOT"]]
        :dependencies [[org.clojure/tools.nrepl "0.2.10"]]}}

*Note - modify the cider-nrepl and tools.nrepl versions if you have issues. It should match the versions you have installed above.

And there you have it! You should be able to fire up Emacs and start a Clojure REPL through cider and even answer a few 4clojure questions as you dive into Clojure. Moving forward, I’m going to try and chronicle my adventures learning Clojure.

Happy hacking!

Introducing Atom One Dark Theme for Emacs

Jonathan Chu — Tue, 09 Jun 2015 00:00:00 -0400

This past weekend I hacked together a new Emacs color theme that is essentially a port of a Atom.io’s One Dark theme.

Here’s the repo for this - One Dark Theme for Emacs

It is based off of the official syntax and UI themes:

I use Emacs as my main text editor for any kind of real work, but I do like to keep up the other editors out there just to keep my ear to the ground. That’s pretty much how I discovered that they added a new core theme called One Dark - when I opened up Atom the other day. :)

And while many may joke around that the world needs “yet another text editor”, I think Atom.io is doing some really great things. For starters, I was really impressed by the active community they already have. Their packaging system really isn’t anything new by standards today, and it’s also arguable that being built by GitHub immediately drew more interest and adoption simply because of the big name backing it, but you can’t deny the sheer number of active participants submitting new, quality packages each day.

Back to the Emacs theme itself, it is a work in progress and pull requests are greatly welcomed! I have not thoroughly covered some of the commonly used modes yet (org-mode for starters), so those tweaks will be forthcoming.

In the screenshot, for those curious the font is Inconsolata and I use smart-mode-line. My whole emacs config can be found in essentially one file here.

Upgrading to Jinja2 Templates in Django 1.8 With Admin

Jonathan Chu — Sun, 26 Apr 2015 00:00:00 -0400

In Django 1.8, a new template system was introduced along with the ability to choose a templating engine, with Jinja2 having built-in support. I tried this out on a newly created Django project and getting setup with Jinja2 was trivial following the docs; however, upon checking the /admin page, I was greeted with this:

Ah, right! The contrib app Admin does not ship with Jinja2 templates. I read through the docs and did not see any mention of using a different template engine in combination with the Django Admin, so I thought I’d share how I solved this to get Jinja2 and the Django Admin templates to work together.

Jinja2 + Django Templates for Admin Link to heading

First, here is a link for the upgrade path to use the new templating system: https://docs.djangoproject.com/en/1.8/ref/templates/upgrading/

Take note of the section that tells you when you can remove things like TEMPLATE_DIRS, TEMPLATE_CONTEXT_PROCESSORS, etc.

Install Jinja2 Link to heading

Make sure Jinja2 is installed:

$ pip install jinja2

In `settings.py` Link to heading

Here is how I defined my TEMPLATES list:

:::python
TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.jinja2.Jinja2',
        'DIRS': [
            os.path.join(BASE_DIR, 'templates/jinja2'),
        ],
        'APP_DIRS': True,
        'OPTIONS': {
            'environment': 'myproject.jinja2.environment',
        },
    },
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.contrib.auth.context_processors.auth',
                'django.template.context_processors.debug',
                'django.template.context_processors.i18n',
                'django.template.context_processors.media',
                'django.template.context_processors.static',
                'django.template.context_processors.tz',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

You need to define both backends in the TEMPLATES setting to be able to use the Django Admin.

Create directory for `jinja2` templates Link to heading

Next, create a jinja2 directory in your project’s templates directory. This is where we are going to put all of our Jinja2 templates.

$ cd <path_to_project>/templates && mkdir jinja2

Create `jinja2.py` Link to heading

Finally, create a file called jinja2.py under your project directory (should be at the same level as your settings.py):

$ cd myproject && touch jinja2.py

And put this in there:

:::python
from django.contrib.staticfiles.storage import staticfiles_storage
from django.core.urlresolvers import reverse
from jinja2 import Environment


def environment(**options):
    env = Environment(**options)
    env.globals.update({
        'static': staticfiles_storage.url,
        'url': reverse,
    })
    return env

This makes static and url available in your Jinja2 templates.

Here’s a tree of the final project structure:

$ tree myproject
myproject
├── myproject
│   ├── __init__.py
│   ├── jinja2.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
├── manage.py
├── templates
│   └── jinja2
│       ├── base.html
│       ├── home.html

PR0FIT! Link to heading

And that should do it! If you go to /admin/ you should see a working admin login. Additionally, whatever templates you put in the templates/jinja2 directory will be processed by the Jinja2 template engine.

Keyboards

Jonathan Chu — Mon, 07 Apr 2014 00:00:00 -0400

I’ve tried out a number of keyboards in the past year in an attempt to move away from my beloved, but aging, Microsoft Natural Ergonomic Keyboard 4000 and wanted to put my reviews of them up for anyone looking for an overview of the ones I tried. A few years back, I developed a small case of carpal tunnel and knew I had to change some of my habits before it got worse - these kind of problems don’t go away on their own! At the time, I was using a second generation Apple wireless keyboard with those chiclet-style keys. I loved it and used it for a few years before the pain started up, and then I had to give it up as it wasn’t the most ergonomic keyboard out there. A friend of mine recommended to try the Microsoft Natural Ergonomic Keyboard 4000 and after reading a quick review online, I purchased one. It took a few hours of getting used to it, but I quickly fell in love with it. The keyboard itself is not eye candy by any means, but it got the job done and best yet, it helped ease the pain in my wrists with the more “natural” positioning of the hands. With its split keyboard layout, cushioned wrist rests built right into it, and a nominal price tag, this easily become my main keyboard. Here’s my quick breakdown of the MS Natural 4000:

Microsoft Natural Ergonomic Keyboard 4000 (*stock photo)

Pros:

Comfortable wrist rests
Generally sane layout, number pad, and function keys - although I don’t use many of them in daily use
One of the lower priced keyboards out there

Cons:

Lack of good key switches
Not form factor - it’s a big keyboard and takes up more room than your standard keyboard with the wrist rests

The next keyboard I tried out was a Das Ultimate S and it was my first experience with a keyboard that had real switches. I got mine with MX Blue switches and they lived up to the hype - man, were they loud! You got a really satisfying feeling when hitting each key and the tactile feel really made for a good combo. In the end, I ended up parting ways with it as it was a bit too loud for my wife since we lived in a one bedroom apartment together in NYC and the clickity-clack would interrupt her shows.

Das Ultimate S (*stock photo)

Pros:

MX Blue switches, although I saw you can get in MX Brown now (a little quieter) from their website

Cons:

Hard to keep clean with glossy polished surface. I found this quite annoying actually, especially with two cats, it made the keyboard look dirty and it smudged easily.

The next keyboard on my list was the Kinesis Maxim. I’ve heard good things about Kinesis from other developers and decided to give them a try. I opted for the Maxim as it was one that was closest to the Microsoft 4000 I was used to using, with a split keyboard layout. I ended up not liking it for one particular reason - the alt key on the left side was smaller than a normal keyboard’s, which made hitting it (Command key for you Mac guys) a bit difficult. As an Emacs user, I found this even more annoying as this led to lots of simple errors.

Kinesis Maxim (*stock photo)

Pros:

Adjustable split keyboard layout
Comfortable wrist rests with sticker pads included - comparable to the Microsoft 4000 on comfort level
Decent key switches

Cons:

Adjustable split gears seemed a bit wonky
Did not like the layout for the control and alt keys
PGUP/PGDOWN, Windows key is in a new column on left side, wtf?!
Alt key on left side is smaller than normal, the layout for command and option key was very small compared to normal alt and Windows key

Microsoft came out with a new ergonomic keyboard recently I was pretty excited to give it a try, being how much I liked their previous ergonomic keyboard. The Microsoft Sculpt Ergonomic came out with a bit higher price tag than the MS 4000, a little more than 2x the cost to be accurate, but I still gave it a shot. It felt pretty natural to me for the split layout and they added a few other things to make it more “up-to-date”.

Microsoft Sculpt Ergonomic

Pros:

Wireless
Split keyboard layout
Comfortable wrist rests
Layout very similar to 4000 with small improvements
Magnetic battery hinge, which was a nice little touch
Separate number pad so you can use it or not, making the
keyboard more form factor

Cons:

Didn’t like the chiclet-style keys
They don’t sell the keyboard separately (as of this writing), so it comes with the mouse too, and the mouse isn’t that great

I used the Sculpt for quite a few months, until I started to miss real switches, thus prompted my keyboard switch yet again. This time I went back to a familiar brand, Kinesis, but tried the Advantage series at recommendation from one of my friends, Wraithan. It was definitely a unique keyboard with a hefty price tag. Unfortunately, it didn’t last more than a week in my possession as I found the learning curve a bit too much to overcome. I’m not a super fast typer, but my speeds range in the 70-80 WPM range with a regular layout keyboard. Using the Advantage, I was down to 30-40 WPM with about 1-2 errors.

Kinesis Advantage

Pros:

Split keyboard
All crucial and most used keys moved to thumb, your strongest finger, to reduce fatigue

Cons:

Big learning curve, the shape and slope of keys slowed me down (show typing tests?)
I found switching back to a regular keyboard layout (like your laptop’s internal keyboard) was getting difficult. As mobile worker, it’s important to work anywhere and having this become an issue was a big one for me
It’s a big and heavy keyboard, even for my tastes, so this is not a good choice if you’re limited on desk space

Finally, this brought me to try out the Happy Hacking Professional 2. What I liked most about this was that the control key was already mapped to the caps lock, which is something I always re-map on a keyboard I use anyway.

Happy Hacking Professional 2

Pros:

Topre key switches
Small form factor
Control key already where I would normally map it

Cons:

Hated where the delete key is
Also hated where the function key is, didn’t seem logical if you had to press the function to use any function keys.

In the end, it’s a great keyboard all around, but the delete key placement didn’t jive with me and is the only reason I am not using this keyboard as my main. Overall, I think I will use this when I travel because of it’s small, compact size, but not as my main keyboard. This inevitably brought me to the Realforce 104U keyboard. This is the current one I’m using today and I am loving it. The lack of a split keyboard layout is not something I’m looking for anymore as I learned to help my wrist pains over the years (stretches before day begins, once at lunchtime, and small breaks on the hour to shake out hands.)

Realforce 104U

Pros:

Variable weighted keys is the biggest win for me. 45g for inner keys, 35g on outside pic
It is a solid keyboard - makes me feel safe if I ever have to fight off any bad guys with this keyboard
Traditional look - almost like an old IBM keyboard, so definitely no learing curve here
Topre key switches, which are not as loud and tactile feeling as cherry swtiches, but somewhere in-between which I’m starting to like

Cons:

The lower weighted keys on the outside aaaaaare more prone to typpppppppppos if you’re one that rests your fingers on the home row like me sometimes ;)
Price

After trying all these keyboards, and consequently going through the return process for most of them, I can happily recommend the Realforce 104U to anyone looking for a professional keyboard with good switches. The variable weighted keys helps me not fatigue as much since the weaker fingers have 35g, stronger fingers have 45g. It’s the closest keyboard to a traditional look-and-feel of an old-school IBM keyboard, with no learning curve, but a higher price tag for what you would expect a high-end keyboard. If you don’t have the space for a full-sized keyboard, I would recommend a Happy Hacking Professional 2.

Django 1.5 Custom User Example

Jonathan Chu — Mon, 23 Sep 2013 00:00:00 -0400

With Django 1.5, one of the biggest changes introduced was the ability to configure the user model. Anyone who has coded a Django app with a business requirement of adding a birthday field, an arbitrary checkbox to the user registration fields, or even making the signup process email-only with no usernames, knows the awkward feeling of implementing their own custom user and feeling a little less Django-esque when all is said and done. This configurable user model change alone was enough for me to 1) upgrade all my Django sites to 1.5 and to 2) swap out my customer user code for the way it should be done now with the configurable user model.

The Django docs are fantastic. It is one of the most comprehensive and, most important, user-friendly documentations out there for programmers of all skill levels. I highly encourage you to read through the docs first on customizing the user model, but isn’t required to understand this walk-through.

If you’re anything like me, you sometimes like to skim or even skip the docs altogether, and turn to Google to try and find a solid example online. I found a few, but none of them really seemed to show me a full example of configuring the user model. As a result, I decided to write my own and put it all together in an example Django project to show how I handled the custom user model. Here is the link to the repo on Github.

This is going to be a brief walk-through in running this example codebase. It is opinionated, but (hopefully!) easily understood - so this would enable you to modify this example codebase slightly to fit your business requirements.

Also, this custom user example is inspired from Dr. Russell Keith-Magee’s great talk at DjangoCon US 2013 titled “Red User, Blue User, MyUser, auth.User” and should serve as a good example for how you can change the core fields of auth.User.

Please note - this walk-through will assume you have pip and virtualenv installed locally, as we’ll be using that to create the environment for the example Django project.

View the source on Github

First, clone the example custom user project and change directory into it:

$ git clone https://github.com/jonathanchu/django-custom-user-example.git
$ cd django-custom-user-example

Then, create your virtual environment. We’ll only be installing Django (v1.5.4):

$ mkvirtualenv customuser(customuser)
$ pip install django

After Django is installed, let’s run syncdb to create our test DB and first superuser. This is configured out-of-the-box to use SQLite3 for simplicity, but feel free to change to whatever database backend you feel more comfortable with. Create your superuser now and follow the prompts:

(customuser) $ python manage.py syncdb...::Follow prompts to create a superuser::

Then we can run runserver to checkout how the custom users in the admin looks:

(customuser) $ python manage.py runserver

And open up your browser to http://127.0.0.1:8000/admin and log in with the superuser you just created. Under “Accounts”, you will see our custom “Users” there. Try it out, take it for a spin, create additional users from the admin, change passwords, etc. This all works nicely with our custom user model!

Hopefully this is helpful to some out there looking for a solid example on customizing the User model. Any issues with the codebase, please use the repo’s issues tracker on Github. Happy hacking!

– Sep 23, 2013

Setting Up Deft Mode in Emacs with Org-Mode

Jonathan Chu — Thu, 15 Aug 2013 00:00:00 -0400

I’ve been a big fan of Notational Velocity for quite a few years now - and more recently, nValt which is a popular fork of Notational Velocity, but with a bit more features. Everyone has their own process when it comes to taking notes, and to each his own, but the one thing that really turned me on to Notational Velocity/nValt is the simplicity and unstructured process of taking and searching for notes. Coupled with Dropbox for seamless syncing, you have yourself a great note taking process that was easy to use and even easier to search. As for mobile, I used Simplenote to view my notes via Dropbox, and it made taking notes during programming meetups or business meetings even easier. Life is good!

However, over the past year, as I found myself coding more and more in my text editor of choice, Emacs - the more I found myself wanting something that didn’t seem so disconnected from where I do most of my prose and coding. After a quick search, I found Jason Blevins’ great little creation called Deft. To sum it up, Deft is an open source mode for Emacs to view, record, and search for notes in plain text, very much like Notational Velocity/nValt. I highly encourage you to check out Jason’s project page for Deft. After trying out Deft, it made me want to switch 100% over to org-mode notes as I really only used org-mode for sporadic notes. Now, I have the power of org-mode with Emacs in a Notational Velocity-like buffer with Deft. The rest of the article will be outlining how I set it up in my Emacs config.

Setting up Deft Link to heading

First, go grab deft.el and make sure it is available in your Emacs config (i.e. - ~/.emacs/vendor/deft.el path). You can grab it here or get it directly from my Emacs config, which is the original unmodified file.

Once deft.el is on your Emacs load path, you’ll need to tell Emacs to use Deft. Put the following anywhere in your config (I like to keep modes separated in it’s own modes.el file that gets loaded on initialization):

(require 'deft)

Since I use Org-Mode, I want *.org files to be recognized by the Deft buffer, so let’s set the deft-extension to “org”. I believe the default file type that Deft will look for is “txt”, so omit this part or add in “txt” if you want to use plain text files.

(setq deft-extension "org")

And again, since I’m using org-mode with Deft, let’s set the deft-text-mode appropriately to use org-mode:

(setq deft-text-mode 'org-mode)

Next, we need to tell Deft where to find all of my current org-mode files. In my case, I like to keep all my org-mode files in Dropbox, so that path would be ~/Dropbox/org for me. You should change this path to wherever you keep your files.

(setq deft-directory "~/Dropbox/org")

Finally, the last bit of customization is to tell Deft to use the filename as a title. By default, Deft will use the first line of the file as the filename. In my note taking preference, I normally don’t lead off a note with the title of the file (it’s usually a date like “2013-08-15” if it’s a meeting), so I switched on the trigger for this:

(setq deft-use-filename-as-title t)

Optionally, you can set deft-auto-save-interval to 0. Its default value is 1.0, which means it saves every second. This is very useful to many, meaning you don’t ever have to manually save your notes since Deft automatically does it for you; however, with my custom emacs config, I prefer to turn this off completely and manually save my notes file because I have a before-save-hook that deletes trailing whitespace. This made typing notes a bit annoying and would often remove whitespace if I was in the middle of writing a sentence, where I didn’t want it to do that yet.

(setq deft-auto-save-interval 0)

Putting it all together, and you have this in its entirety:

;; deft
(require 'deft)
(setq deft-directory "~/Dropbox/org")
(setq deft-extension "org")
(setq deft-text-mode 'org-mode)
(setq deft-use-filename-as-title t)
(setq deft-auto-save-interval 0)

Using Deft Link to heading

To enter the Deft buffer, simply do:

m-x deft ENTER

And you should see the Deft buffer like so, with all of your org-files (yes, I know - nothing is blurred out…I got nothing to hide :P ):

Start typing and you’ll see the list of notes filter out the results that do not match, just like Notational Velocity. Hit ENTER to open the note in a new buffer.

And there you have it! Much appreciation and thanks goes to Jason Blevins for this awesome mode that has effectively streamlined my coding and note-taking all in Emacs!

– Aug 15, 2013

Org-Mode and MobileOrg Installation and Config

Jonathan Chu — Wed, 10 Jul 2013 00:00:00 -0400

Intro Link to heading

Throughout the years, I’ve flipped back and forth between Org-Mode and applications such as Drafts (iOS), Evernote, Simplenote, and even plain ol’ text files (with the Notational Velocity and nValt) for my most basic note-taking needs; however, I’ve always found myself coming back to Org-Mode in the end for another spin around the block. The one positive thing that kept me coming back to Org-Mode, and perhaps the same thing that Emacs is often criticized for, is the fact that it has a lot of functionality under the hood - almost too much. Org-Mode is a very feature-rich application. For my basic needs, I use Org-Mode primiarly for three things:

Basic note-taking and outlines
TODO lists
Tracking and clocking time

Here Comes MobileOrg Link to heading

When I first learned about MobileOrg, I was really stoked that I would be able to record notes, update TODO statuses, and even just view my org files on the go. Unfortunatley, I found that the basic setup instructions on their website left a few minor things out for someone new to MobileOrg, and this is my attempt to supplement that to help others with the same issues I faced with setup.

Org-Mode Configuration Link to heading

First off, it should be noted that I’m using Emacs 24 with Org-Mode already baked in. If you’re using an earlier version of Emacs that doesn’t have Org-Mode by default, please install it according to your own preference (which we won’t get into here since there are a few different ways to install Org-Mode).

My root directory for all of my org files is kept in Dropbox in a directory called org:

~/Dropbox/org

I’ve found that this setup fits my workflow best since I also work off a second laptop at times and would like all my org files to be synced across all machines with as little effort as possible.

MobileOrg Setup Link to heading

Next, install MobileOrg from the App Store. I chose the path of least resistance and decided to use Dropbox as the source for server config, so when you first open the application, click on the Dropbox option, click to link account, and allow authentication with Dropbox to proceed. It should have created a new directory for you under:

~/Dropbox/Apps/MobileOrg

Emacs Configuration for MobileOrg Link to heading

You will need a few more lines of code to get this all working with your local org files and MobileOrg. This is my basic config based on the two main directories above that will need to go in your Emacs config:

;; mobileorg settings
(setq org-directory "~/Dropbox/org")
(setq org-mobile-inbox-for-pull "~/Dropbox/org/inbox.org")
(setq org-mobile-directory "~/Dropbox/Apps/MobileOrg")
(setq org-mobile-files '("~/Dropbox/org"))

Finally, from within Emacs - edit any org file located in ~/Dropbox/org/ and save those changes. Then send these changes to MobileOrg to sync up:

M-x org-mobile-push

With any luck, you should be able to go back to MobileOrg on your mobile device and click the refresh button to see your org file(s) all there.

Happy hacking!

Upgrading PostgreSQL 9.0 to 9.1 with pg_upgrade

Jonathan Chu — Tue, 19 Jun 2012 00:00:00 -0400

Recently, I updated all of the packages I have installed via Homebrew and ran into some issues with the PostgreSQL package. I was getting this error:

The data directory was initialized by PostgreSQL version 9.0, which is not compatible with this version 9.1.4

A quick search took me to this page, however the docs left a lot to be desired to say the least. Here’s a step-by-step to how I eventually fixed it using pg_upgrade.

First, change directories to your Postgres data directory.

$ cd /usr/local/var

Next, create a new directory for the new data directory.

$ mkdir postgres9

Use initdb to initialize the new Postgres cluster in the new data directory you created above.

$ initdb /usr/local/var/postgres9

Run pg_upgrade with the following arguments:

$ pg_upgrade -d /usr/local/var/postgres/ -D /usr/local/var/postgres9 -b /usr/local/Cellar/postgresql/9.0.4/bin/ -B /usr/local/Cellar/postgresql/9.1.4/bin/ -v

If all goes without error, you can switch the data directories so Postgres will point to the right source.

$ mv postgres postgres9.0.1
$ mv postgres9 postgres

You can delete the script left behind by pg_upgrade:

$ rm delete_old_cluster.sh

I actually had my old Postgres instance running, so I had to stop it before restarting the new one:

$ pg_ctl -D /usr/local/var/postgres9.0.1 stop -m fast

Then I restarted the new Postgres instance:

$ launchctl unload -w homebrew.mxcl.postgresql.plist
$ launchctl load -w homebrew.mxcl.postgresql.plist

And you’re done - this should fix the PostgreSQL incompatible data directory issue.

Installing OpenTera on a TeraStation

Jonathan Chu — Sun, 27 May 2012 00:00:00 -0400

I have a Buffalo TeraStation that I bought in 2006 to store all my big media files. Through the years it has served me well, although with Mac OS X Lion, connectivity to the TeraStation stopped working altogether - mainly due to Lion’s changed AFP connectivity. Usually with hardware of this age, it would be simply replaced; however, I’ve always found Buffalo’s hardware to be of great quality which is a testament to how long it’s lasted. Sadly, installing OpenTera has been on my TODO list for roughly a year now, so this fix is overdue. Buffalo officially responded that there will be a firmware fix for this in the future, but that was over a year ago. This is a quick walkthrough of how I got read/write access back on the TeraStation through Mac OS X Lion. Note: I did the download and firmware updates from my Windows PC, telnet from Mac OS X Lion.

Find out the firmware version of your TeraStation. At the time of writing, I have v2.14. Download the corresponding firmware version from this site and install it. This is essentially the same firmware but with telnet enabled. You’ll need telnet enabled to log into the TeraStation to install OpenTera.
Download OpenTera Update v5 and Samba 3 from this site. Unzip and move this on the TeraStation where you can later access it. I moved this into my “Share” directory.
Telnet into the TeraStation. I believe the default user for the firmware is “myroot”, which you should use to telnet in.

$ telnet 192.168.0.108Trying 192.168.0.108… Connected to 192.168.0.108. Escape character is ‘^]’. Password:Login incorrect

TERASTATION login: myroot root@TERASTATION:~#
Change directories into the OpenTera directory, the one you just placed on the TeraStation, and run the Update_OpenTera.sh script.

root@TERASTATION:/# cd mnt/array1/share/OpenTera_v5/ root@TERASTATION:/mnt/array1/share/OpenTera_v5# ./Update_OpenTera.sh

This script is an interactive install, so it will prompt you to say “y” a few times. Go ahead and do so. If all is successful, you should see:

[OpenTera] ============ OpenTera Install Completed ===============

Next, change directories into the Samba directory and run the Update_Samba.sh script.

root@TERASTATION:/mnt/array1/share/OpenTera_v5# cd /mnt/array1/share/samba-3.0.37_ppc/ root@TERASTATION:/mnt/array1/share/samba-3.0.37_ppc# ./Update_Samba.sh

When all is completed, you should see:

*********************************************************************
                Completed samba-3.0.37_ppc.tgz install
*********************************************************************

And that’s it! I was able to access the TeraStation from Mac OS X Lion. Hopefully this will be helpful to someone else out there, as I know I’m not the only one with this problem. If I missed any steps, let me know - good luck!

Applications I Use

Jonathan Chu — Fri, 02 Mar 2012 00:00:00 -0400

About two years ago, I bought my dad a MacBook Pro as a gift and with him being a long-time Windows user, the transition wasn’t seemless to say the least. I wanted to write an article on the applications I use to give him an idea of what’s out there. So here are some common and not-so-common applications I use on a daily basis:

General Link to heading

Alfred

Alfred is a handy utility app that has a lot more functionality than what I use it for. It lets you search and open applications quickly with a few key strokes by simply typing the first few letters of the application name.

1Password

A password manager app. I don’t know any of my passwords anymore. You keep one password that unlocks the “vault” and it gives you access to all of your passwords. Mine are randomly generated. Save your encrypted passwords file to Dropbox so you can have it on other devices (iPad, iPhone, or any other machine that can run 1Password).

Dropbox

For effortless syncing between machines and helpful for sharing files, pictures, etc.

Fantastical

Quick entry of appointments in your calendar. Uses natural language and parses it to extract the date, time, and title of meeting. You can type in: “Lunch with Lydia tomorrow afternoon at 1pm” and it will create an calendar event for you correctly.

Cloud App

An easier way to share screenshots. You can set it up auto-upload every time you take a screenshot and it automagically copies the sharable URL to your clipboard.

Shady

For when working late at night, you can turn down the brightness of your screen. It has presets, so once you activate it, it will dim to your custom setting without having to fiddle with the System Preferences each time you want to dim or turn back on your brightness.

Caffeine

Keeps your screen from dimming or shutting off. Useful when I’m unplugged and on the go - if I don’t want the screen to dim after a few minutes of inactivity, I simply turn this on. Helpful when others are looking on at your laptop and you’re discussing something. You won’t need to keep touching the touchpad every minute or two so it won’t dim. Sure, you can change this in your System Preferences, but the idea is to NOT have to keep modifying the presets so it’s not intrusive.

smcFan Control

A simple little app that sits in your top menu bar and tells you the internal temperature. I like to keep an eye on this when I work - it tells me if there’s an application that’s eating up a lot of CPU, because the fans would turn on and the temperatures would rise. Also lets you control the fan speed.

Fluid App

I use this app to make web apps seem like a native application. For example, instead of visiting my company’s Basecamp URL, I can make the web application into a (fake) standalone application. Now, I can just launch “basecamp” in Alfred and it will open up a dedicated browser for Basecamp.

Divvy

I use this for quick organization of my applications and windows. You can have presets for sizes that you like to repeat, such as half-screen, full-screen, etc. Useful when working with several applications, such as a browser, terminal, and emacs, and keeping a visual on them all at once.

Coding Link to heading

Emacs

I’ve been using Emacs for a few years now and the muscle memory is definitely ingrained where I feel more productive in it than almost anything else.

Textmate 2

Another editor that I used heavily before diving (back) into emacs. Out of habit, it’s more of a crutch than anything else. I still find myself using it for viewing project tree structures and quick searching throughout the project.

iTerm 2

An alternative to Terminal, much more feature-rich.

Charles

Made its way into my daily development arsenal as of recently. Has become extremely useful in seeing all the responses the applications I’m coding is making.

Chrome and developer tools, Firefox, Safari

My browsers of choice, in that order.

GitX

I use a fork of this and prefer it over some of the newer git GUIs out there.

SourceTree

Another good one, only reason why it’s on here is because it’s free (for now), so go ahead and grab a copy before they start charging! Great product.

Versions

I begrudgingly use this because I have one remaining project on SVN, which will soon be no more. It makes working with SVN somewhat bearable.

Sequel Pro

Great GUI for MySQL databases remote and local.

pgAdmin3

GUI for PostgreSQL databases remote and local. I use this in conjunction with pgphpmyadmin.

Transmit

(S)FTP client.

Frontend/Design Link to heading

Photoshop CS5

Need I say more?

xScope

For making sure everything is pixel perfect and colors match exactly in the websites I code. Has been an indespensible tool throughout the years.

Pixelmator

Great alternative to Photoshop. I’m not a designer, but sometimes when Photoshop chokes on opening a specific file, Pixelmator always seems to come through in the end.

Balsamiq Mockups

Great tool for quick wireframing and rapid prototyping.

ImageOptim

Use this to additionally compress your images and get them ready for website use to ensure speed in loading the media assets.

Business Link to heading

Billings

This is a great app that I use daily to track my time and send invoices. It also lets me see what payments are outstanding from each client. It has a handy timer in the menu bar that lets you track time at any given point with whatever you’re doing.

OmniPlan 2

Great tool that I started using last year to create estimates for clients. I mostly love any tool that Omni Group makes.

Notational Velocity with Simplenote integration

Great for quick, free form note taking. Notational Velocity lets you simply type in search terms in the top bar and it will search your notes for it.

iA Writer

Simple, fantastic tool for writing. Has Markdown support!

Soulver

A neat little calculator that uses some natural language to give you the answer.

ScanSnap Manager Amazon link, since Fujitisu is more likely to change their URL than Amazon.

I scan all my physical documents with the ScanSnap S1500M and use OCR scanning to make the entire document searchable.

Social/Fun Link to heading

Adium

I use Adium for instant messaging as it allows you to sign in with multiple types of accounts at once. I know iChat is getting better, but I’ve been a long time user of Adium and feels like home to me.

Propane

Great dedicated application for Campfire, so you don’t need to use the browser to access it. Feels more like native IM now.

Textual

Great GUI for IRC. I used to just connect in my Emacs window, however it proved to be too distracting when working.

Echofon

My Twitter client of choice.

Reeder

Great Google Reader application, now with Readability support.

Skitch

Great to making those always funny memes…and sending work stuff to people.

That’s it! Link to heading

Like many people in my profession, I consider myself to be a bit of a software junkie…and with good reason! Just like with programming languages - there’s always the right tool for the right job. This was a fun little exercise to go over the tools I use on a daily basis and I hope this is helpful for some out there. In one of next articles, I plan to write more about my development workflow and the tools I use in greater detail.

2011 In Review

Jonathan Chu — Sat, 21 Jan 2012 00:00:00 -0400

Since it seems that everyone and their mother is doing a “year in review” post, I find it fitting that I be no different and write one as well - except it’s three weeks later than everyone else. 2011 was an exciting year for me for a variety of reasons, as I went through some big work and life changes, met some great new friends, and reunited with a few long lost ones.

Work Link to heading

In February of 2011, I left my job at exhibit-E where I was a web developer making web sites for the art world. Over the past few years, I’ve always done freelance work on the side whether it be small contract jobs or building full social networking websites as a solo developer. My decision to leave exhibit-E seemed to make sense now - I wanted to see if I had what it took to survive as a full-time freelancer while working under my own company name before I got too old and perhaps couldn’t take on so much risk. I wasn’t too concerned with finding work, but more so about being able to GROW my own company; the latter obviously being the hardest part. Within a week or two, I managed to land myself a great gig as the lead developer for the RachaelRayShow.com…and now it was off to the races!

Conferences Link to heading

In March, I went to PyCon 2011 in Atlanta, GA. This was my first programming conference and I met some fantastically smart people there - some of which I’m fortunate to actually work with right now on some of 3atmosphere’s current projects, and some that I still keep in contact with via email. The talks were great and the “networking” at night (aka exploring ATL’s nightlife) was the best part of the trip. I’m really looking forward to returning to PyCon again this year.

Nick holding up his new laptop that we bought at a mall in Atlanta during PyCon…during iPad 2 (insanity) launch day!

More Work! Link to heading

Over the next few months into the early summer, the project load at 3atmospheres really started to pick up. I take pride in the fact that I never made one cold call or solicited ads for work - all the requests we got in were from word-of-mouth and I couldn’t be more proud of our humble beginning. It picked up so much that the once lonely one-man show (me!) turned into (at the peak) six people working on several different projects. I found myself quickly transitioning from coding to project management, which I would say still is evenly split for me today. Out of necessity for a meeting spot, we bought some seats at General Assembly where we currently work.

On a personal note, I got engaged at the end of the summer to my lovely girlfriend of over four years, Patricia, which easily made 2011 the best year of my life thus far.

More Conferences! Link to heading

In September, I was fortunate enough to get to go to three conferences:

DjangoCon (Portland)
PyGotham (NYC)
Strata Conference (NYC)

And for the rest of the fall season into winter, it was just work, work, and more work - literally every free hour I had was devoted to meeting the deadlines that were set at the end of the year.

Let’s Wrap It Up… Link to heading

2011 was a great year and I’ve never worked harder, been more tired, and, at the same time, had as much fun as I’ve ever had in my professional career. I am so lucky to have gotten to meet and work with such smart people, clients and coworkers alike, and I’m extremely proud at how far we’ve come today. Admittedly, it wasn’t always rainbows and butterflies with work, but for all the negative moments I’ve had this year, I’ve used it as a learning experience and I wouldn’t trade it for a second. I get to program in languages and frameworks of my choosing (Python and Django!) and get to work with people that are smarter than me. Here’s to a great 2011 and an even better 2012!

Virtualenv and pip Basics

Jonathan Chu — Wed, 09 Feb 2011 00:00:00 -0400

When doing any kind of Python development, one tool I find indispensable is virtualenv. Virtualenv, along with virtualenvwrapper and pip, make for a great way to completely isolate your development environment.

When I first started out developing Django sites, I used to use easy_install to install all packages I needed to the system-wide site-packages directory. Even as a newbie to Django, I knew this wasn’t good practice, but it ensured that commonly used libraries such as MySQL-python was available without any extra configuration with new projects. Regardless, completely isolating your environment with virtualenv ensures that a) you don’t install conflicting packages and b) any bugs introduced in your project can be traced back directly to the packages you installed. Also, a huge benefit is that it makes installing multiple versions of Python super easy without having to create any symlinks.

Getting started with Virtualenv and pip Link to heading

The first thing you will need to do is install pip. If you have setuptools installed, which you most likely will with most modern platforms, you can install pip through easy_install:

easy_install pip

Next, you’ll need to install virtualenv with pip:

pip install virtualenv

Finally, I would highly recommend installing virtualenvwrapper as it makes it much easier to create and start virtual environments:

pip install virtualenvwrapper

As part of the install instructions for virtualenvwrapper, you need to add this to your .bash_profile

# virtualenv
export WORKON_HOME=$HOME/.virtualenvs
source /Library/Frameworks/Python.framework/Versions/2.7/bin/virtualenvwrapper.sh

Please note that this path may differ depending on what version of Python you have. Also, I like to keep all my virtualenvs in a directory called .virtualenvs in my home directory, but this may differ for you if you choose to keep your virtual environments in a different directory.

Make sure you source your new .bash_profile

source ~/.bash_profile

…and that’s it! Now you’re all set to start using virtual environments!

Creating a Virtual Environment Link to heading

A few handy aliases I have in my .bash_profile are found on Doug Hellmann’s blog and listed below:

# virtualenv aliases
# http://blog.doughellmann.com/2010/01/virtualenvwrapper-tips-and-tricks.html
alias v='workon'
alias v.deactivate='deactivate'
alias v.mk='mkvirtualenv --no-site-packages'
alias v.mk_withsitepackages='mkvirtualenv'
alias v.rm='rmvirtualenv'
alias v.switch='workon'
alias v.add2virtualenv='add2virtualenv'
alias v.cdsitepackages='cdsitepackages'
alias v.cd='cdvirtualenv'
alias v.lssitepackages='lssitepackages'

This saves some keystrokes, especially since I always create new virtual environments with the --no-site-packages switch to ensure a completely clean environment.

To create and start a new virtual environment with --no-site-packages, enter:

$ v.mk myvirtualenv
New python executable in myvirtualenv/bin/pythonInstalling setuptools............done.
(myvirtualenv) $

This creates and virtual environment and makes it active. To deactivate it, you can simply type:

(myvirtualenv) $ deactivate
$

So let’s go ahead and start our virtual environment once again and install some packages to it.

$ v myvirtualenv
(myvirtualenv) $

We’re going to install Python package Yolk as it is a useful command line utility that lists the packages installed for the environment.

(myvirtualenv) $ pip install yolk
Downloading/unpacking yolk
  Downloading yolk-0.4.1.tar.gz (80Kb): 80Kb downloaded
  Running setup.py egg_info for package yolk

Requirement already satisfied (use --upgrade to upgrade): setuptools in /Users/jonathan/.virtualenvs/myvirtualenv/lib/python2.7/site-packages/setuptools-0.6c11-py2.7.egg (from yolk)
Installing collected packages: yolk
  Running setup.py install for yolk

    Installing yolk script to /Users/jonathan/.virtualenvs/myvirtualenv/bin

Successfully installed yolk
Cleaning up...

Now you can use yolk -l to list the packages installed for this virtual environment:

(myvirtualenv) $ yolk -l
Python          - 2.7.1        - active development
(/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/lib-dynload)
pip             - 0.8.1        - active
setuptools      - 0.6c11       - active
wsgiref         - 0.1.2        - active development
(/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7)
yolk            - 0.4.1        - active

Here is a brief one-line example showing how to create a virtualenv and install Django, MySQL Python, South, Python Imaging Library (PIL), and ImageKit using pip:

$ v.mk newdjangoenv
(newdjangoenv) $ pip install django MySQL-python south pil django-imagekit

When you have your requirements installed, it’s always good to take a snapshot of the requirements and the current versions. You can do this by typing freeze and specifying an output file:

(newdjangoenv) $ pip freeze > requirements.txt

And finally, you can use the requirements.txt file so that your environment is completely and easily replicable:

$ pip install -r requirements.txt

And there you have it – you can now create and test your Python applications in completely isolated environments!

For more on pip and virtualenv, check out this great post by Salty Crane which got me started on all this.

New Blog Platform

Jonathan Chu — Tue, 18 Jan 2011 00:00:00 -0400

After a long blogging hiatus, I recently decided to switch over my custom Django blog to a static site generator, following the trend that many others have started. What made the switch so appealing, going from a full-featured blogging engine to a simple static site generator, was that I could write my blog entries in a text editor of my choice and keep everything under version control with Git. A simple push to the production server would serve my static pages up via Nginx, which in the end would take up far less resources and memory than a Django-powered blog application or even Wordpress. So with that, I decided to search for a static site generator that would suit me. I did some research and narrowed my choices down to three static site generators:

Jekyll (Ruby-based)
Hyde (Python-based)
Growl (Python-based)

Jekyll is the creation of @mojombo, in which he refers to it as “Blogging Like a Hacker” as he so eloquently put it in his article. He pretty much hit the nail on the head; blogging becomes a bit of a hassle when you use a complicated blogging engine like Wordpress and the likes. Many are using Jekyll and seem to be very happy with it.

In the end, I decided to go with Growl. I chose Growl because it was pure Python, had support for Jinja2, and was extremely lightweight with few dependencies. I decided not to go with Jekyll, arguably the most popular static site generator currently out there, because I wasn’t too fond of the templating language. Also, I decided not to go with Hyde simply because I prefer Jinja2 over Django templates, which is utilized in Hyde.

Growl is written by Rico Schiekel and “shamelessly stole some really cool ideas from Jekyll”, which is absolutely awesome in my opinion. I think it’s great that software can be created from borrowing the best parts of other pieces of software, regardless of language.

This blog is written and compiled with a slightly modified version of Growl. So far, I’m loving the writing process:

Write the article in Emacs
Commit to Git repository
Rsync the changes to my production server
…and that’s it!

You can find out more about Growl by reading its documentation. Here are some of the main features of Growl:

Pages and posts have a YAML header
Pages and posts are written in Markdown
Layouts are written in HTML and Jinja2

The basic structure of my blog looks something like this:

_hooks contains Python scripts that extend Growl
_layout contains the basic layouts for your site
_libs contains any third party libraries you want to use
_posts contains all the posts
css and img contain all the stylesheets and site media, respectively

All files that end with an underscore, such as index.html_ for example, get processed by Growl as a page. All processed pages and media assets get dumped in the deploy directory, which serves up your static site.

Posts need to be named in the following structure:

2011-01-18-new-blog-platform.md2

When the posts are processed by Growl, the date 2011-01-18 gets parsed and the directory structure is created - http://jontourage.com**/2011/01/18/new-blog-platform/**

As for the post content itself, it simply is a mix of YAML and Markdown. Here’s an example of what a post header looks like:

---
layout: post
title: New Blog Platform
publish: false
---

And the rest of the post is just Markdown! When I’m done writing the article, I simply push to GitHub and sync up the production server using a rsync hook:

$ growl.py --deploy jontourage

And that’s it! You can checkout my blog and the structure in more detail here.

Review: MacBook Air 13

Jonathan Chu — Mon, 10 Jan 2011 00:00:00 -0400

I recently decided to purchase a MacBook Air to use as my primary computer, saying goodbye to my previous laptop - a 15" MacBook Pro with a HiRes AntiGlare display, 2.66GHz i7, 8GB RAM, and 500GB HD @ 7200RPM, NVIDIA GeForce GT 330M with 512MB memory. I went with the 13", 2.13GHz Core 2 Duo, 4GB RAM, 256GB flash storage configuration and could not be happier with its performance. Portability was a very important factor to me in making this decision, as I carry my laptop with me everyday. It’s been serving as my primary computer for the past three weeks and the transition has been absolutely seamless.

Hardware Link to heading

The Air weighs in at about 3 lbs and is surprisingly sturdy in terms of build. Being a MacBook Pro user for most of my developer life, I was a little wary that the build quality was going to be less sturdy from what I’m used to, which was not the case at all. The glossy screen on the Air was a concern of mine before purchasing, especially since I just came from a matte display. The glossy screen on the stock MacBook Pro’s is just too glossy for me to not be annoying. The Air is a good middle ground - albeit not matte, it offers good enough contrast and isn’t as glossy as the MacBook Pro line. One thing I am missing on the Air is a backlit keyboard. The lack of ethernet port has never bothered me as I have a wireless-N network at home which offer better speeds than your average B/G network.

One thing that does annoy me is that the Air does not fit well on my Rain Design mStand. As you can see in the picture below, aluminum does not rest on the pads because of the thinness.

Performance Link to heading

Despite the fact that the Air has a far inferior processor and only half the amount of RAM as my previous laptop, I can honestly say that the Air just feels faster. Most applications launch within one second, such as the Microsoft Office apps, while the Adobe CS5 Suite launches within a respectable two to three seconds. The flash storage is the obvious difference maker here. As for configuration, I decided to start with a new install and not restore from a Time Machine backup. The first thing I did was install Xcode and Homebrew, along with a bunch of apps that I use daily for development. At the end of the whole config and install process, the Applications folder takes up about 15GB and my iTunes library takes up about 47GB of disk space, leave roughly 135GB remaining - which is more than enough space left. Considering what’s on the flash storage, it takes ~15 seconds to boot up and ~25 seconds to shut down.

The resolution on the Air is 1440x900, which is the same as the 15" MacBook Pro, but greater than the 13" MacBook Pro’s 1280x800. When I’m at home, the Air is connected to my Apple LED Cinema Display 24" model (discontinued) and supports 1920x1200. The connectors make for a perfect fit being that the MiniDisplay Port is on the right side of the laptop, while the power and USB are on the left.

As far as graphic intensive applications and games, I haven’t tried playing any games or doing any video editing, but I can imagine there will be some limitations. I’ve read in several places that games such as World of Warcraft and StarCraft II run perfectly fine on the MacBook Airs and may even start up faster, but the framerate is lower. This is a limitation I can deal with given the hardware.

Likes Link to heading

Portability
Boots up in about 15 seconds
Almost all applications launch within 1-3 seconds
Battery life upwards of 8 hours (50% screen brightness)

Dislikes Link to heading

Glossy screen
No backlit keyboard
Not (easily) upgradable

Conclusion Link to heading

I feel like the MBA is changing the way I work and I absoutely love that. Now that I have a more portable laptop, I find myself working in places that I normally wouldn’t (and didn’t with my 15" MacBook Pro, i.e. - on the couch in front of the TV). If not having a DVD drive is a dealbreaker, I would say this isn’t the laptop for you. All in all, I could not be happier with the Air. It’s an excellent laptop and has been able to handle all my tasks with ease.

Posts on jonathanchu.is

Introducing magit-gh

Why I wrote this Link to heading

Installation Link to heading

Usage Link to heading

What’s next Link to heading

Introducing magit-git-toolbelt

What it does Link to heading

Screenshot Link to heading

Installation Link to heading

Usage Link to heading

Why Link to heading

Code Forensics on init.el

Dark Mode Toggle for iTerm and Emacs

Emacs, Notmuch, isync, and msmtp Setup

Receiving email Link to heading

Viewing and writing email Link to heading

Sending email Link to heading

EmacsConf 2019 Magit Deep Dive

Getting Started with Emacs and Clojure on OS X

Introducing Atom One Dark Theme for Emacs

Upgrading to Jinja2 Templates in Django 1.8 With Admin

Jinja2 + Django Templates for Admin Link to heading

Install Jinja2 Link to heading

In settings.py Link to heading

Create directory for jinja2 templates Link to heading

Create jinja2.py Link to heading

PR0FIT! Link to heading

Keyboards

Django 1.5 Custom User Example

Setting Up Deft Mode in Emacs with Org-Mode

Setting up Deft Link to heading

Using Deft Link to heading

Org-Mode and MobileOrg Installation and Config

Intro Link to heading

Here Comes MobileOrg Link to heading

Org-Mode Configuration Link to heading

MobileOrg Setup Link to heading

Emacs Configuration for MobileOrg Link to heading

Upgrading PostgreSQL 9.0 to 9.1 with pg_upgrade

Installing OpenTera on a TeraStation

Applications I Use

General Link to heading

Coding Link to heading

Frontend/Design Link to heading

Business Link to heading

Social/Fun Link to heading

That’s it! Link to heading

2011 In Review

Work Link to heading

Conferences Link to heading

More Work! Link to heading

More Conferences! Link to heading

Let’s Wrap It Up… Link to heading

Virtualenv and pip Basics

Getting started with Virtualenv and pip Link to heading

Creating a Virtual Environment Link to heading

New Blog Platform

Review: MacBook Air 13

Hardware Link to heading

Performance Link to heading

Likes Link to heading

Dislikes Link to heading

Conclusion Link to heading

In `settings.py` Link to heading

Create directory for `jinja2` templates Link to heading

Create `jinja2.py` Link to heading