Cabin Notebook and Fakir

After postponing for years I’ve been working on a website that I haven’t found the equivalent of, Cabin Notebook, which is currently populated (seeded) only with random data.

I’ve been using the excellent Faker Ruby gem, but found its random data to be … too random. That is, I didn’t want truly repeating random data, such as its wide variety of prefix+first+middle+last+suffix names and phone number formats (“Dr. Millie Beatrice Houndhouse III”, “(812)-555-1213” and “1-312-555-9696”), and having the same random number be used repeatedly (such as subsequent labels of “Photo #2”, annotating different photos). Fakir will also support a more flexible version of Array#rand, so that a random element will not be returned within N invocations of that method.

So I’ve created the fakir gem, which supports data that are not quite so random. It’s in the beginning stages, but I plan to have it soon be fully-featured enough to seed the data at Cabin Notebook.

Earlier anacron jobs

For whatever reason, anacron is set to run its daily jobs at 7:30 in the morning:

# /etc/cron.d/anacron: crontab entries for the anacron package


30 7    * * *   root	start -q anacron || :

The first time I encountered that was when I was working at that time of day and noticed the sluggishness of my machine. It seemed that locate was the heavyweight process, so I changed anacron to run at 4:30 a.m, modifying the last line in the file:

30 4    * * *   root	start -q anacron || :

New Z shell blog

I’ve started a blog exclusively about the astonishingly powerful Z shell.

Check it out here: Focus on Zsh.

The goal is to find some of the more interesting and complex examples of Zsh code, and to break them down, explaining them line by line. Despite having worked with Zsh for many years (over a decade), I consider that I’ve barely scratched the surface of what it can do, and, not finding many instructive Zsh resources, have decide to create one.

Please take a look, and I look forward to your feedback.

No dots in cron scripts?

I added a little script to /etc/cron.daily,, while I sorted out how to integrate my backup script (tresync) into the list of cron jobs run daily.

The odd thing is, the script never ran. I could run it as “sudo /etc/cron.daily/“, but it didn’t run with the rest of the cron jobs.

Lo and behold, I found the answer, which is actually on the man page for run-parts:

If neither the –lsbsysinit option nor the –regex option is given then the names must consist entirely of ASCII upper- and lower-case letters, ASCII digits, ASCII underscores, and ASCII minus-hyphens.

Which means: you cannot have a dot in the file name.

That seems quite counterintuitive, but perhaps there is a reason that I just don’t understand.

Printing the middle N lines of a file in Linux

While working on my “e” alias in my aforalias project, I want the show only the entries of zip files, that is, without the header and footer sections. The “e” alias also shows the entries sorted by name, unlike the behavior of “unzip -l“, which displays:

  Length      Date    Time    Name
---------  ---------- -----   ----
---------                     -------
102761855                     9503 files

Thus I wanted to print lines[3 .. lines.length – 3].

Lo and behold, there’s a way to do that with “head” and “tail”, as follows:

unzip -l $1 | tail -n +4 | head --lines=-2

tail -n +X” means “start printing at line X”, where 1 is the first line of the file (not 0).

And “head --lines=-X” means “print all but the last X lines”.

Not the most intuitive pair of commands in this context, but they can be quite helpful.

A for Alias

In Zsh (and other shells), aliases may be the most important feature for increased productivity.

A simple rule is this: the more often you run a command, the shorter it should be. I’ve written about this before, in Efficient Way to Improve Console Productivity.

I have a number of one-character aliases:

G='| glark'
H='| head'
L='| less'
M='| more'
S='| sort'
T='| tail'
h='history -5000'
l='ls -CF'

I’ll write later about those nifty uppercase ones (and yes, there is the alias “a” for “alias”, but for now, I’ll just show them with examples:

alias G -g '^.='

That was the command that I ran to generate the list above. It expands to “alias | glark -g ‘^.='”.

find src -type d S

That finds all directories and pipes them to sort.

There are three “families” of commands that I run the most often:

  • diff – diff files
  • eye – look at/in files on the command line
  • find – list all files/directories matching a pattern
  • open – open files in editor, browser
  • search – look in files

So I have been writing one-character scripts/functions (in Bash) for each of the above, where the script understands context as well as the targets.

For example, “s pluralize” run from a directory that contains a “Rakefile” will expand to search (using glark) only for Ruby files.

e program.tar.gz” is the equivalent of “tar ztvf program.tar.gz“, and “e” lists the zip file, with entries sorted by name.

d dir1 dir2” runs a recursive diff on the directories, and “d path/to/file ../dir2” will diff “path/to/file” against “../dir2/path/to/file”, if the latter file exists. I do this to avoid the tedious repetition of comparing one code base to another (such as two branches, when merging them): “diff path/to/file1 ../dir2/path/to/file1“, “diff path/to/file2 ../dir2/path/to/file2“, etc.

Although this project is in its early stage, and the output is still rough (i.e., containing debugging output), it already has been quite useful, so I thought I would share.

The project is at Github here.

Life Organization: The Eight Categories

This is a a system for organizing and assessing one’s life, that of eight categories. Since some people have asked me about them, I thought I would enumerate them here.

These categories can be used these to plan — days, weeks, months, and years — as well as to self-assess (“journal”) every day, keeping a record. The journaling/recording process will be described in a separate post.

Physical: sleep, diet, body data (weight, fat percentage, resting heart rate), medical and dental procedures, and of course, exercise.

Professional: formal work (9 to 5) and corollary activities, such as job- and career-related reading, blogs, pod casts, and tutorials.

Social: family and friends, including time spent face-to-face, phone calls, messaging, and email.

Solitary: activities and time not for social or professional reasons, done purely for oneself.

Maintenance: work on physical surroundings, such as home and car. This also includes organization of files and records, both physical and electronic.

Mental: reading and brain-developing exercises.

Emotional: activities (and lack thereof) to regain emotional balance, such as meditating, yoga, prayer and even music.

Financial: money, including tracking spending, paying bills and investing.

The categories are not intended to be unique. In fact, if activity can fall into multiple categories it can be considered to be efficient in terms of maximizing results for the effort (although it might also be diluting the results as well). The categories that overlap most often for me are solitary and mental. For example, since I am an avid Scrabble player I could classify that in either category, but I put it as solitary, generally keeping the mental category limited to reading. Likewise yoga could be either physical or emotional.

One of the main motivators for developing the categories was when I was concerned that my life was getting out of balance, leaning heavily toward professional, and this helps to keep a broader perspective.

The above categories can also be used for organizing in other aspects. For example, electronic documents could go into different directories (or folders), named for the above. So college transcripts would go into the professional directory, medical records in physical, appliance manuals in maintenance, tax documents in financial and e-books in mental.

Cost of Meet(ing)

I’ve long been frustrated that meetings are not quantified, where the cost of the meeting is calculated based on the wages of those in the meeting. With that data, it would be more obvious to determine that cost/benefit of the meeting.

Some back-of-the-envelope calculations here. For four people making an average salary of $100,000 (I’m using programmer gross salaries, including benefits and vacation), a 30-minute meeting would run $96. For twelve people for two hours: $769. Twenty people for two eight-hour days (for example, training): $15,385.

Since I’ve been trying to spin up my web skills I slapped together a site that acts a bit like a timer for a meeting. It’s built on Rails, yet uses little of the framework, other than some of the JavaScript libraries and routing.

Please check it out:

Rails testing and Emacs mode line

I’ve been diving/digging into the oh-so-excellent Rails Tutorial, by Michael Hartl, and am into chapter 3, where testing begins.

Imagine my surprise — go ahead, imagine it — when my Emacs mode line changed color.



And when I ran “bundle exec rake test”, it succeeded with:


Then changing the test code to fail, after running “bundle exec rake test” again:


Tracking down this code, I found that the guard-notiffany gem was doing this behavior, sending a change to the Emacs mode line via emacsclient, with this bit of code in lib/notiffany/notifier/emacs.rb:

        def notify(color, bgcolor)
          elisp = <<-EOF.gsub(/\s+/, " ").strip
            (set-face-attribute 'mode-line nil
                 :background "#{bgcolor}"
                 :foreground "#{color}")

The issue there was that it just changes the mode line “permanently”. I’d prefer that the mode line colors change for a moment, then time out and revert to their previous settings.

I wrote a bit of code to do this, and modified lib/notiffany/notifier/emacs.rb locally, but there is a pending pull request that has a better implementation.

However, my hack is:

        def notify(color, bgcolor)
          elisp  = "(let ((orig-bg (face-attribute 'mode-line :background))"
          elisp << "      (orig-fg (face-attribute 'mode-line :foreground)))"
          elisp << "     (set-face-attribute 'mode-line nil"
          elisp << "                         :background \"#{bgcolor}\""
          elisp << "                         :foreground \"#{color}\")"
          elisp << "     (sit-for 3)"
          elisp << "     (set-face-attribute 'mode-line nil"
          elisp << "                         :background orig-bg"
          elisp << "                         :foreground orig-fg))"

The sit-for keeps the mode line as red or green for 3 seconds or when there is Emacs input. I prefer that, to clear the mode line more quickly, since I find the bright color distracting.