The Writing PHP with Emacs book page has been updated with a free chapter. It covers adding syntax checking to Emacs via flycheck.

The book is currently priced at $9.99, but will be increasing to $19.99 on March 31st. All future updates are included with the initial purchase.

Read the free chapter: Checking syntax (and more) with flycheck

The first month of the year went very quickly (which apparently is a yearly experience for me). Most of my focus was spent on getting myself organized for the year ahead, but I also spent some time working on games. Here's how January went:

My full Emacs configuration consists of multiple packages and a few thousand lines of elisp code. The whole thing is then synchronized between my development machines so that I have a common environment to work in.

This setup works well enough, but it's a little heavyweight. For machines that don't require the full configuration - such as a Raspberry Pi - I use a much more streamlined setup. This version strips away some graphical elements I don't use, puts backup files in a single location, and sets up packages that I use every day.

The packages I use most frequently are:

• use-package - For cleaner configuration files.
• no-littering - For keeping my ~/.emacs.d/ tidy.
• helm - For faster navigation.

;; Turn off menu bar, tool bar, and scroll bar.
(if (fboundp 'menu-bar-mode)   (menu-bar-mode   -1))
(if (fboundp 'tool-bar-mode)   (tool-bar-mode   -1))
(if (fboundp 'scroll-bar-mode) (scroll-bar-mode -1))

;; Turn off the splash screen.
(setq inhibit-startup-message t)

;; Set path to .emacs.d
(setq dotfiles-dir (file-name-directory
		    (or (buffer-file-name) load-file-name)))

;; Don't use tabs for indentation.
(setq-default indent-tabs-mode nil)
(setq-default tab-width 4)

;; Enable upcase/downcase region.
(put 'upcase-region   'disabled nil)
(put 'downcase-region 'disabled nil)

;; Store backup files under ~/.emacs.d/backups
(setq backup-directory-alist `(("." . ,(expand-file-name
					(concat dotfiles-dir "backups")))))

;; Maximize window when frame opens.
(add-to-list 'default-frame-alist '(fullscreen . maximized))

(require 'use-package)

I use helm for finding files, switching buffers, and running commands with M-x. The configuration looks like this:

;; -------------------------------------------------
;; -- Helm - automatic completion buffers.

(use-package helm
  :diminish helm-mode
  :init
  (require 'helm-config)
  (customize-set-variable 'helm-ff-lynx-style-map t)
  (customize-set-variable 'helm-imenu-lynx-style-map t)
  (customize-set-variable 'helm-semantic-lynx-style-map t)
  (customize-set-variable 'helm-occur-use-ioccur-style-keys t)
  (helm-mode 1)
  :config
  (add-to-list 'helm-completing-read-handlers-alist '(switch-to-buffer . ido))
  :bind (("C-c h" .   helm-mini)
	 ("M-x" .     helm-M-x)
	 ("C-x C-f" . helm-find-files)
	 ("C-x b" .   helm-buffers-list))
  :custom
  (helm-candidate-number-limit 100)
  (helm-idle-delay             0.0)
  (helm-input-idle-delay       0.01)
  (helm-quick-update           t)
  (helm-M-x-requires-pattern   nil)
  (helm-ff-skip-boring-files   t))

If I'm doing any kind of programming work I'll want magit and projectile installed too. I use the defaults for magit, and my projectile configuration is also pretty slim:

;; -------------------------------------------------
;; -- Projectile - project navigation

(use-package projectile
  :diminish projectile-mode
  :config
  (projectile-mode)
  :custom
  (projectile-keymap-prefix     (kbd "C-c p"))
  (projectile-enable-caching    t)
  (projectile-completion-system 'default))

(use-package helm-projectile
  :init (helm-projectile-on))

Finally there are some key bindings that I like:

;; Disable C+z closing because I'm too clumsy.
(global-set-key "\C-z" #'do-nothing)
(defun do-nothing ())

;; Use M-` to switch between frames.
(global-set-key "\M-`" #'other-frame)

;; Jump to a line number.
(global-set-key "\C-x\C-l" #'goto-line)

Last year I took part in a 30 day blogging trial. It went pretty well, so this year I'm aiming for 100 posts over the course of the year. There's less pressure when publishing twice a week, but I'm finding it harder to write on this schedule.

I think this is related to my game development struggles; I've written games in 48 hours, but give me a month to do it and suddenly I fall apart.

There are some advantages to writing twice a week. I can spend additional time writing more detailed posts. There were some things I wanted to write about during my 30-day sprint that I didn't have the time to do. With a full week I can give them more attention they need.

However, on the twice-weekly schedule I'm rejecting more ideas and leaving more posts in the "draft" folder. Having that daily deadline pushed me to get ideas out the door as I didn't have time to get them "perfect". I think that's probably true of all my creative work.

Ideally I'd like be able to mix in daily writing with longer posts. I found daily writing to be helpful when exploring ideas, but it requires a lot of time and mental energy. I might end up with a hybrid approach where I post daily for a week and then write a longer article the week after.

I've been using Pocket to manage my reading list for about a year now. There are a couple of features that I really like:

• Articles can be saved directly from Firefox and then picked up later on a different device.
• Articles can be tagged with one (or more) categories.
• Highlights can be added and saved in the reader view.

I frequently highlight articles, but I realized I don't actually do anything with them. It doesn't really matter how vigilant I am about highlighting interesting ideas if I don't make use of them.

As part of my goal this year to improve my processes, I wanted to get these highlights out of Pocket and into my zettelkasten system.

The current process I'm using looks like this:

• Step 1 - Create a single note for the article which contains all of its highlights.
• Step 2 - Read through each highlight and decide if it's something I want to keep or convert.
• Step 3 - Rewrite the book highlight in my own words as a new note.

It follows a similar thought process to my GTD setup: notes come in, I decide what to do with them, and then I convert them to something else or discard them entirely.

An example note

This is a note from the article "How to Improve Your Productivity as a Working Programmer" before processing:

And this is what it looks like after processing and editing:

The finished note has no content of its own, but acts as an index to all of its related notes. Sometimes I'll add a little excerpt or summary to the top if the title is non-obvious.

An extracted note looks like this:

—

By the end of the process the note has been turned from a few chunks of copy-pasted text into a page that links to my personal thoughts about an article. It's a fairly quick process once I'm in the groove, although I need to get better about scheduling it as frequently as my weekly GTD reviews.

One important part of this system is to be comfortable with rearranging things. When I first started keeping notes I wanted everything to be perfectly organized on the first try, but it often takes multiple passes before I'm completely happy.

Further reading:

• The Zettelkasten Method: Examples to help you get started
• Create Zettel from Reading Notes According to the Principle of Atomicity