Weekly review: Week ending January 30, 2015

This week was the week of focusing on vegetables. I made Japanese curry with a pickled salad on the side (daikon, cucumber, carrot), shepherd’s pie, and pad thai. It was great to have so many vegetable-focused dishes in the fridge. Looking forward to exploring more recipes and building up this habit!

Blog posts

  1. Weekly review: Week ending January 23, 2015
  2. Filling in the occupational blanks
  3. Sketchnote Hangout: Playing with colour
  4. Emacs kaizen: helm-swoop and editing
  5. Writing: Open loops, closed loops, and working with forgetfulness
  6. Emacs microhabit: Switching windows with windmove, ace-window, and ace-jump
  7. Read business books more effectively through application, visualization, or reviews
  8. Learning to work on my own things
  9. Getting data from Org Mode tables
  10. Finding a model for my sharing

Sketches

Link round-up

Focus areas and time review

  • Business (33.3h – 19%)
    • Deposit cheque
    • Earn: E1: 1-2 days of consulting
    • Earn: E1: 1-2 days of consulting
    • Earn (7.1h – 21% of Business)
    • Build (15.2h – 45% of Business)
      • Drawing (13.7h)
      • Delegation (0.0h)
      • Packaging (0.0h)
      • Paperwork (0.7h)
      • Look into recently uploaded images
    • Connect (10.9h – 32% of Business)
      • Talk to Srid
  • Relationships (5.9h – 3%)
  • Discretionary – Productive (15.3h – 9%)
    • Emacs (5.7h – 3% of all)
      • Improve my mail handling
      • Make graphviz easier with Emacs Lisp
      • Try out Tern
      • Help Sean
      • Make a montage of selected sketches based on their filenames
      • Change my set-descriptions.js to be able to use any blog URLs (archive page, future post, etc.)
    • Pick up cultural access pass from Front and Parliament
    • Reflect on asking questions
    • Apply for passport
    • Invest in bonds in TFSA
    • Process a 10lb bag of potatoes
    • Type in goals
    • Read Intermediate Japanese – chapter 1
    • Read chapter 2
    • Write about open loops
    • Collect words and examples from tweets about Emacs
    • Read chapter 3
    • Writing (5.3h)
  • Discretionary – Play (3.0h – 1%)
  • Personal routines (31.6h – 18%)
  • Unpaid work (20.3h – 12%)
  • Sleep (58.6h – 34% – average of 8.4 per day)

Finding a model for my sharing

Can a sharing model based on free/pay-what-you-want resources be sustainable over a long period of time?

I’ve been thinking about this for a number of reasons:

  • One of my assistants e-mailed me about my difficulties with delegation. He suggested thinking of my life as a business: What would my objectives be? When I reflected on that, I realized I had some discomfort around the ideas of customers and business models. Was my life more like science and exploration? Not quite, either. I left the thread of thought unresolved.
  • Problogger posted this mind map of different ways to monetize a blog. I realized that I’m not keen on advertising, physical products, selling/flipping blogs, premium content/communities/products, affiliate marketing (except for books I like, and even then those offer tiny commissions and it feels a little hypocritical to do that given that I hardly ever buy books myself), and other indirect methods. I might be okay with coaching, if I can come up with a good workaround for the impostor syndrome.
  • In an interview about Quantified Self and life experiments, a journalist asked me to describe my business. I felt that social business consulting wasn’t the real crux of my current life’s work, and that talking about writing and publishing e-books would be incomplete without exploring why free/pay-what-you-want pricing is important to me. Answering his question prompted me to think about my motivations a bit more.
  • Harold Jarche wrote about the exposure economy and his decision to limit his sharing. I understand where he’s coming from – by mom gives similar lectures to aspiring photographers who have yet to internalize that “exposure” won’t buy them new equipment. But there’s something else that drives me to share more, not less, and I want to understand that.
  • @ljconrad retweeted a link to The Gift of Being Uncommon, which included a segment on “gift reciprocity versus market economy.” It says that people “may have difficulty charging sufficiently for their work, especially if they view their own abilities, products or insights as gifts that need to be shared with others.” I’ve requested Lewis Hyde’s book The Gift: Creativity and the Artist in the Modern World from the library, and I’m looking forward to digging into it further.
  • The contrast of a gift culture versus a market economy reminded me of Eric S. Raymond’s “Homesteading the Noosphere” (2000). I revisited its sections on gift culture, art, and reward. It made me think: Is reputation a major driver for me? How does this work out if my ideal outcome does not involve parlaying that reputation into economic opportunities like jobs or gigs?
  • And that reminded me of Tom Morkes’ guide to pay what you want pricing, and the breadth of people using the PWYW strategy. I’m always delighted to get a note from Gumroad that someone has purchased one of my resources, but I’m still working on getting my anxious side to accept that this is okay.

So that’s my context.

Mulling all those things, I realized that the model I can use to understand my desire to share isn’t business (with its customers, markets, and exchanges of value) or modern science (with its funding from institutions and competition around publications).

It’s philosophy. Ancient philosophy, not professionalized modern philosophy.

What were the “business models” for ancient Greek and Roman philosophers? How did they sustain themselves?

2015-01-10 How did schools of philosophy work in ancient Greece and Rome -- index card #independence #philosophy

2015.01.10 How did schools of philosophy work in ancient Greece and Rome – index card #independence #philosophy

2015-01-10 More about philosophers -- index card #independence

2015.01.10 More about philosophers – index card #independence

  • The Cynics begged in the streets. (I’d rather avoid that option.)
  • People or schools received gifts (from students, from other people in the community, etc.).
  • People or schools had rich patrons.
  • People charged tuition, offered private tutoring, and so on.
  • People worked in unrelated occupations. For example, Cleanthes philosophized during the day and carried water at night.
  • People had private means: estates, investments, and so forth. Seneca had a fortune (acquired through less-palatable means). Atticus inherited wealth and grew it through real estate.

Some philosophers taught in closed schools: Pythagoras kept an exclusive brotherhood. Others taught in public, like Zeno did.

I don’t quite think of what I do as philosophy, but I can learn from how these schools worked. For example, using philosophy as a lens, it makes sense to me to share in public for the following reasons:

  • More people can learn.
  • Ideas stand a greater chance of being remembered and used. (By other people, and by me!)
  • I can grow from the conversation.

This last point is particularly important to me. I’m still figuring things out. I don’t feel that I’m quite at the stage where I can teach people well – when I have clear paths and well-tested lessons. I’m still at the stage where I try to live as well as I can, making and sharing useful things. People’s questions often help me realize something I didn’t know I knew. I’m nowhere close to sharing wisdom suitable for the ages (and might never be).

2015-01-11 Current state and future states -- index card #writing

2015.01.11 Current state and future states – index card #writing

With that learner’s perspective, it doesn’t make sense to me to limit the circle of people I can reach, or to charge people for the privilege of my being able to learn from them. But it does make sense to be open to gifts – of money, sure, but especially of time, skills, experience, and perspective.

2015-01-10 Lessons from ancient Rome -- index card #philosophy

2015.01.10 Lessons from ancient Rome – index card #philosophy

In fact, reflecting on how ancient philosophers managed their ups and downs helped me address more of my anxiety over whether a financial mistake might break this freedom. After all, life back then was way more volatile than life is now. What’s a downturn in the stock market like compared to the whims of emperors and the possibility of exile? I have fewer pressures on my life and more resources than people back then could imagine. (Searchable books! The Internet! Amazing text editors! Boggle.) If I want to learn about interesting things, potential changes in my situation shouldn’t stop me.

So here we are. I don’t know if Kevin Kelly is right about 1,000 True Fans (or John Scalzi about a larger, more modest base). “Fan” isn’t quite what I’m going for, anyway. I want co-adventurers, co-figure-out-ers – ideas bumping into each other in conversations, the back-and-forth of experiments. Maybe a teacher will appear and guide me. Maybe students will help me discover what I can teach. I’ve found some role models to help me understand sharing, and I’m looking forward to seeing if that can still work in the modern world – or better yet, what we can do with it.

Getting data from Org Mode tables

Org Mode is an amazingly powerful package for Emacs. I’ve been learning a lot about how to use its support for plain-text tables and spreadsheet calculations.

Using table data in Emacs Lisp with the :var argument

For example, I wanted to be able to define my abbreviations in an Org Mode table in my config. I remembered coming across this technique a few weeks ago, but I couldn’t find the webpage with the code. It turned out to be simple to write from scratch. Here’s the plain text I added to my config.

#+NAME: abbrev
| Base  | Expansion                             |
|-------+---------------------------------------|
| bc    | because                               |
| wo    | without                               |
| wi    | with                                  |
| ex    | For example,                          |
| qm    | [email protected]                   |
| qe    | http://sachachua.com/dotemacs         |
| qw    | http://sachachua.com/                 |
| qb    | http://sachachua.com/blog/            |
| qc    | http://sachachua.com/blog/emacs-chat/ |

#+begin_src emacs-lisp :exports code :var data=abbrev
(mapc (lambda (x) (define-global-abbrev (car x) (cadr x))) data)
#+end_src

The :var data=abbrev argument to the Emacs Lisp source block is where all the magic happens. Here, it takes the data from the table named “abbrev” (which I set using #+NAME: before the table) and makes it available to the code. Emacs evaluates that data when the code is tangled (or exported) to my configuration. The code that’s in my Sacha.el looks like this:

(let ((data (quote (("bc" "because")
                    ("wo" "without")
                    ("wi" "with")
                    ("ex" "For example,")
                    ("email" "[email protected]")
                    ("dote" "http://sachachua.com/dotemacs")
                    ("web" "http://sachachua.com/")
                    ("blog" "http://sachachua.com/blog/")
                    ("ec" "http://sachachua.com/blog/emacs-chat/")))))
  (mapc (lambda (x) (define-global-abbrev (car x) (cadr x))) data) )

Looking up data with org-lookup-first, org-lookup-last, and org-lookup-all

You can do more complex things with Org tables, too. Inspired by Eric Boyd’s talk on his Epic Quest of Awesome (which he based on Steve Kamb‘s), I started putting together my own. I made a list of little achievements, guessed at the years, and assigned arbitrary experience points.

The achievements table had rows like this:

Approximate date Category XP Description ID
2014 Life 50 Became a Canadian citizen – link L_CAN
2014 Programming 20 Used NodeJS and AngularJS for a client project – link P_NOD
2014 Programming 5 Pulled information out of Evernote

I wanted to summarize the points by year: points gained, total points, level (according to a lookup table based on D&D experience points), and description. The lookup table was structured like this:

#+TBLNAME: levels
| Total XP | Level | Adjective             |
|----------+-------+-----------------------|
|        0 |     1 | trained-initiate      |
|     1000 |     2 | experienced           |
|     2250 |     3 | savvy                 |
|     3750 |     4 | veteran               |
|     5500 |     5 | unusually experienced |

Now for the summary table. I created rows for different years, and then I used Org Mode to fill in the rest. (Org Mode! Wow.)

| Year | Points gained | Cumulative points | Level | Adjective        |
|------+---------------+-------------------+-------+------------------|
| 1997 |             0 |                 0 |     1 | trained-initiate |
| 1998 |            10 |                10 |     1 | trained-initiate |
| 1999 |            50 |                60 |     1 | trained-initiate |
| 2000 |            50 |               110 |     1 | trained-initiate |
| 2001 |           100 |               210 |     1 | trained-initiate |
| 2002 |            60 |               270 |     1 | trained-initiate |
| 2003 |           245 |               515 |     1 | trained-initiate |
| 2004 |           115 |               630 |     1 | trained-initiate |
| 2005 |           140 |               770 |     1 | trained-initiate |
| 2006 |            60 |               830 |     1 | trained-initiate |
| 2007 |           270 |              1100 |     2 | experienced      |
| 2008 |           290 |              1390 |     2 | experienced      |
| 2009 |           205 |              1595 |     2 | experienced      |
| 2010 |           215 |              1810 |     2 | experienced      |
| 2011 |           115 |              1925 |     2 | experienced      |
| 2012 |           355 |              2280 |     3 | savvy            |
| 2013 |           290 |              2570 |     3 | savvy            |
| 2014 |           350 |              2920 |     3 | savvy            |
| 2015 |            45 |              2965 |     3 | savvy            |
#+TBLFM: $2='(calc-eval (format "vsum(%s)" (vconcat (org-lookup-all $1 '(remote(accomplishments,@2$1..@>$1)) '(remote(accomplishments,@2$3..@>$3))))))::$3=vsum(@2$2..@+0$2)::$4='(org-lookup-last $3 '(remote(levels,@2$1..@>$1)) '(remote(levels,@2$2..@>$2)) '>=);N::$5='(org-lookup-last $3 '(remote(levels,@2$1..@>$1)) '(remote(levels,@2$3..@>$3)) '>=);L

The TBLFM (table formula) line is very long, so let me break it down.

Points gained:

(calc-eval
 (format "vsum(%s)"
         (vconcat
          (org-lookup-all
           $1
           '(remote(accomplishments,@2$1..@>$1))
           '(remote(accomplishments,@2$3..@>$3))))))

This uses org-lookup-all to look up the value of the first column ($1) in the accomplishments table, from the second row to the last row @2..@>, looking in the first column ($1). It returns the values from the third column of the matching rows ($3). This is then passed through calc’s vsum function to calculate the sum.

Cumulative points: vsum(@2$2..@+0$2) is the sum of the second column $2 from the second row @2 to the current row @+0.

Level: This uses org-lookup-last to find the last value where the operator function returns true. In this case, testing the level from column $3 against each of the values in the levels table’s column $1 while the given level is greater than or equal to the value from levels. When it finds the last matching row, it returns the $2 second column from it. ;N means treat everything as a number.

org-lookup-first is like org-lookup-last, but it returns the first matching row.

Adjective: This one works like Level does, but it returns the value from column $3 instead. I found that it converted the return values to 0 if I used ;N, so I used ;L instead.

Passing data to R or other external programs

Of course, you’re not limited to things that Emacs can do. I wanted to summarize the data in graphs, so here’s what I did.

#+RESULTS: category_analysis

#+name: category_analysis
#+begin_src R :var data=accomplishments :exports both :results graphics :file quest_category.png :height 300
library(plyr)
library(ggplot2)
categories <- ddply(data, c("Category"), summarize, Points=sum(XP))
cat_sorted <- transform(categories, Category=reorder(Category, Points))
plot <- ggplot(data = cat_sorted, aes(x = Category, y = Points))
plot <- plot + geom_bar(stat="identity")
plot <- plot + geom_text(aes(label = Points, x = Category, y = Points + 10, hjust=0))
plot <- plot + scale_y_continuous(expand=c(0,70))
plot <- plot + coord_flip()
print(plot)
#+end_src

I like including source code in published pages for fellow geeks, but having the results come first gives people more context for the source block. So I named the source block using the #+name: directive and defined a #+RESULTS: directive before it. The source block used the :var argument to bring the data in from the accomplishments table. With R blocks, the data becomes available as a data frame that you can then do interesting things with. I used the :file argument to save the output to quest_category.png.

Those are a few ways that you can get data out of Org Mode tables and into Emacs Lisp, other Org Mode tables, or external programs. As I learn more about Org Mode, I find myself using it for more of the things that I used to use Microsoft Excel for – tracking, analyzing, and even graphing. I found it a little difficult to piece together what I needed to do from the manuals and examples on the Web, so I hope this explanation will help you (and that it’ll help me when I forget the syntax, as I’m sure I will). If you come up with something really neat that uses Org Mode tables, tell me what you’ve figured out!

Learning to work on my own things

My annual review showed me that despite my resolution to reduce consulting and focus more on my own stuff in 2014, I actually increased the amount of time I spent working on client projects than I did in 2013 (12% vs 9%). Sure, I increased the amount of time I invested in my own productive projects (15% of 2014 compared to 14% in 2013) and the balance is still tilted towards my own projects, but I’d underestimated how much consulting pulls on my brain.

This is the fourth year of my 5-year experiment, and I’m slowly coming to understand the questions I want to ask. In the beginning, I wanted to know:

  • Do I have marketable skills?
  • Can I find clients?
  • Can I build a viable business?
  • Can I get the hang of accounting and paperwork?
  • Can I manage cash flow?
  • Can I work with other people?
  • Can I deal with uncertainty and other aspects of this lifestyle?
  • Can I manage my own time, energy, and opportunity pipeline?

After three years of this experiment, I’m reasonably certain that I can answer all these questions with “Yes.” I’ve reduced the anxiety I used to have around those topics. Now I’m curious about other questions I can explore during the remainder of this experiment (or in a new one).

In particular, this experiment gives me an rare opportunity to explore this question: Can I come up with good ideas and implement them?

I’m fascinated by this question because I can feel the weakening pull of other people’s requests. It’s almost like a space probe approaching escape velocity, and then out to where propulsion meets little resistance and there are many new things to discover.

The most worthwhile thing I’m learning from this experiment, I think, is to sit with myself until the urge to work on other people’s projects passes. Arbitrarily deciding that Tuesdays are no longer consulting days (leaving only Thursdays) seems to work well for me. I find that I can pick things up readily on Thursdays. The rest of the time, I think about my own projects. Mondays and Wednesdays are writing days, Tuesdays are coding days, and Fridays are for administration and wrapping up.

2015-01-05 Developing my imagination and initiative -- index card

Last year, I found it easy and satisfying to work on other people’s requests, and harder to figure out what I wanted to do. It’s like the way it’s easier to take a course than it is to figure things out on your own, but learning on your own helps you figure out things that people can’t teach you.

What’s difficult about figuring out what I want to do and doing it? I think it involves a set of skills I need to develop. As a beginner, I’m not very good, so I feel dissatisfied with my choices and more inclined towards existing projects or requests that appeal to me. This is not bad. It helps me develop other skills, like coding or testing. Choosing existing projects often results in quick rewards instead of an unclear opportunity cost. It’s logical to focus on other people’s work.

One possibility is to build skills on other people’s projects until I run into an idea that refuses to let go of me, which is a practical approach and the story of many people’s businesses. The danger is that I might get too used to working on other people’s projects and never try to come up with something on my own. In the grand scheme of things, this is no big loss for the world (it’ll probably be all the same given a few thousand years), but I’m still curious about the alternatives.

The other approach (which I’m taking with this experiment) is to make myself try things out, learning from the experience and the consequences. If I’m patient with my mediocrity, I might be able to climb up that learning curve. I can figure out how to imagine and make something new – perhaps even something that only I can do, or that might not occur to other people, or that might not have an immediate market. Instead of always following, I might sometimes be an artist or even a leader.

What would the ideal outcome be? I would get to the point where I can confidently combine listening to people and coming up with my own ideas to create things that people want (or maybe didn’t even know they wanted).

How can I tell if I’m succeeding? Well, if people are giving me lots of time and/or money, that’s a great sign. It’s not the only measure. There’s probably something along the lines of self-satisfaction. I might learn something from, say, artists who lived obscure lives. But making stuff that other people find remarkable and useful is probably an indicator that I’m doing all right.

What would getting this wrong be like? Well, it might turn out that the opportunity cost of these experiments is too high. For example, if something happened to W-, our savings are running low, and I haven’t gotten the hang of creating and earning value, then I would probably focus instead on being a really good follower. It’s easy to recognize this situation. I just need to keep an eye on our finances.

It might also turn out that I’m not particularly original, it would take me ages to figure out how to be original in a worthwhile way, and that it would be better for me to focus on contributing to other people’s projects. This is a little harder to distinguish from the situation where I’m still slowly working my way up the learning curve. This reminds me of Seth Godin’s book The Dip, only it’s less about dips and more about plateaus. It also reminds me of Scott H. Young’s post about different kinds of difficulty.

As a counterpoint to the scenario where I find out that I’m not usefully original and that I’m better off mostly working on other people’s things, I hold up:

  • my Emacs geekery, which people appreciate for both its weirdness and their ability to pick out useful ideas from it
  • the occasional mentions in books other people have written, where something I do is used to illustrate an interesting alternative

So I think it is likely that I can come up with good, useful ideas and I can make them happen. Knowing that it’s easy to get dissatisfied with my attempts if I compare them with other things I could be working on, I can simply ignore that discomfort and keep deliberately practising until either I’ve gotten the hang of it or I’ve put in enough effort and must conclude that other things are more worthwhile.

 

If you find yourself considering the same kind of experiment with freedom, deciding between other people’s work and your own projects, here’s what I’m learning:

It’s easy to say yes to other people’s requests, but it might be worthwhile to learn how to come up with your own.

Read business books more effectively through application, visualization, or reviews

This Quora question on “What is the most effective way to read a book and what can one do after reading?” got me thinking about how I read business books and what I do to make the most of them.

2015-01-08 How to use what you read -- index card

2015.01.08 How to use what you read – index card

Application: The best way to get value from a book is to apply it to your life. Reading The Lean Startup is one thing. Using its Build-Measure-Learn loop to run a business experiment is another. Reading Your Money or Your Life is one thing. Calculating your true hourly wage and using that to evaluate your expenses is another. Do the work.

As you apply an idea, you’ll probably want to refer back to the details in the book, so it’s good to keep the book itself handy. Write notes about your questions, ideas, TODOs, experiences, and follow-up questions.

Visualization: Not ready to do the work yet? Slow down and think about it. Imagine the specific situations where you would be able to apply the ideas from the book, and how you would do so. What do you need to learn or do in order to get there? See if you can get closer to being able to act on what you’ve learned.

Spend some time thinking about how the ideas in the book connect to other books you’ve read or ideas you’ve explored. What do they agree with or disagree with? Where do they go into more detail, and where do they summarize? What new areas do they open up?

Think about specific people who might be able to use the ideas in the book. Get in touch with them and recommend the book, explaining why they might find it useful. Imagine what kind of conversation the book might be relevant to so that you’ll find it easier to recognize the situation when it arises. (This is a tip I picked up from Tim Sanders’ Love is the Killer App, which I often recommend when people want to know more about how reading helps with networking.)

Review: Can’t act on the book yet, and can’t think of specific people or ideas to relate it to? Take notes so that you can review them later, and maybe you’ll be able to think of connections then.

I don’t like writing in books. Here’s why:

  • Most of my books come from the library, and I’d never write in those. This lets me get through lots of books without the friction of committing money and space to them.
  • Highlighting is an easy way to make yourself think that you’re going to remember something. Also, it’s hard to decide what’s important the first time through, so you might end up highlighting too much. When everything’s important, nothing is.
  • There’s rarely enough room in the margins for notes, and you can’t review those notes quickly.

2015-01-09 Take notes while you read books -- index card

2015.01.09 Take notes while you read books – index card

I prefer to write my notes on an index card or a piece of paper. If I’m near my computer, I might draw my notes on a tablet or type quotes into a text file. Keeping my notes separate from the book lets me review my notes quickly without thumbing through the book. I want to be able to refer to my notes while reading other books or while writing my reflections. Index cards, pages, and print-outs are easy to physically rearrange, and text files can be searched. Even if I read an e-book, I take my own notes and I copy highlights into my text files.

The best way to remember to review a book is to schedule an action to apply an idea from it. The second-best way is to connect it to other ideas or other people. If you don’t have either of those hooks, you can review on a regular basis – say, after a month, six months, and a year, or by using a spaced repetition system. You might even pull a book out at random and review your notes for inspiration. When you do, see if you can think of new actions or connections, and you’ll get even more out of it. Good luck, and happy reading!

Emacs microhabit: Switching windows with windmove, ace-window, and ace-jump

When I work with a large monitor, I often divide my Emacs frame (what most people call a window) into two or more windows (divisions within a frame). I like this more than dealing with multiple Emacs frames, even if I could spread those frames across multiple monitors. I find it easier to manage the windows using keyboard shortcuts than to manage the tiling and display of frames.

One of the Emacs micro-habits I’m working on is getting better at switching between windows. When there are only two windows, C-x o (other-window) works just fine. However, when there are three or more, it can take a few repetitions of C-x o to get to where I want. I could get around that by binding other-window to M-o instead, replacing the default keymap for that. Or I could try to get the hang of other ways to move around.

Here’s an 8-minute video showing windmove, ace-window, and ace-jump:

https://www.youtube.com/watch?v=nKCKuRuvAOw&list=UUlT2UAbC6j7TqOWurVhkuHQ

Windmove lets you move around with cursor keys, if you set up the appropriate keyboard shortcuts. Ace-window works like ace-jump. In addition, you can use C-u to swap windows and C-u C-u to delete windows. Ace-jump works across windows, so that’s handy too.

Here’s my relevant code snippet for Windmove. I changed this to use define-key instead of bind-key.

(defvar sacha/windmove-map (make-sparse-keymap))
(define-key sacha/windmove-map "h" 'windmove-left)
(define-key sacha/windmove-map "t" 'windmove-up)
(define-key sacha/windmove-map "n" 'windmove-down)
(define-key sacha/windmove-map "s" 'windmove-right)
(define-key sacha/windmove-map "[left]" 'windmove-left)
(define-key sacha/windmove-map "[up]" 'windmove-up)
(define-key sacha/windmove-map "[down]" 'windmove-down)
(define-key sacha/windmove-map "[right]" 'windmove-right)
(key-chord-define-global "yy"     sacha/windmove-map)

Here’s the cheat sheet I made for myself:

2015-01-12 Emacs microhabit - window management -- index card #emacs

2015-01-12 Emacs microhabit – window management – index card #emacs

And here’s a simpler reference that you can personalize with your own shortcuts:

2015-01-18 Emacs microhabit - Switching windows -- index card #emacs #microhabit

2015-01-18 Emacs microhabit – Switching windows – index card #emacs #microhabit

Naturally, after recording the video, I thought of a better way to manage my windows. I took advantage of the def-repeat-command that abo-abo posted on (or emacs so that I could repeat keybindings easily. I modified the function to accept nil as the first value if you don’t want the keymap to run a command by default, and to use kbd for the keybinding definitions.

  (defun sacha/def-rep-command (alist)
    "Return a lambda that calls the first function of ALIST.
It sets the transient map to all functions of ALIST,
allowing you to repeat those functions as needed."
    (lexical-let ((keymap (make-sparse-keymap))
                  (func (cdar alist)))
      (mapc (lambda (x)
              (when x
                (define-key keymap (kbd (car x)) (cdr x))))
            alist)
      (lambda (arg)
        (interactive "p")
        (when func
          (funcall func arg))
        (set-transient-map keymap t))))

Here’s my new binding for yy. It lets me bounce on y to use other-window as normal, use the arrow keys to move between windows thanks to windmove, and use ace-window as well: h is the regular ace-window, s swaps, and d deletes.

(key-chord-define-global "yy"   
      (sacha/def-rep-command
       '(nil
         ("<left>" . windmove-left)
         ("<right>" . windmove-right)
         ("<down>" . windmove-down)
         ("<up>" . windmove-up)
         ("y" . other-window)
         ("h" . ace-window)
         ("s" . (lambda () (interactive) (ace-window 4)))
         ("d" . (lambda () (interactive) (ace-window 16)))
         )))

Neat, eh?