Category Archives: wickedcoolemacs

On this page:
  • Wicked Cool Emacs: get in on the action!
  • Outline for task management chapter
  • Why I use Emacs to manage my tasks
  • A day in a life with Org
  • One day with Planner
  • Get a grip on your tasks

Wicked Cool Emacs: get in on the action!

Ever since I started on this “Wicked Cool Emacs” project with No Starch Press, I’ve run into all sorts of amazing geeks who have been working on something similar. For example, Ted Roden‘s further along in writing the book than I am. It would be a shame to waste that effort. <laugh>

I would love to work on this book with other people. I think that it would become an even better book than I could write by myself, just as Emacs is better because all these people have worked on it. Besides, I’d love an opportunity to widen my Emacs network!

So here’s the outline I planned:

Preface 15 pages
A Day in the Life 30 pages
Customizing Emacs 20 pages
Working with Files 80 pages
Working with Code 40 pages
Browsing the Web 15 pages
Reading Mail with Gnus 30 pages
Being Big Brother 30 pages
Taking Notes 35 pages
Managing Tasks 35 pages
Managing Your Schedule 20 pages – DRAFTED AND SENT, YAY!
Other weird stuff ?

I’d be totally happy to co-author this book with someone else who can commit time over the next year to help me do it. Take a look at the first chapter I’ve written: Organizing your schedule (OpenOffice.org document). I know you can do better than that. =) Let’s find out how wonderful we can make this book.

If you’re seriously interested in coauthoring this, get in touch with me and we’ll talk to the folks over at NSP.

On Technorati: , ,

Random Emacs symbol: message-insert-disposition-notification-to – Command: Request a disposition notification (return receipt) to this message.

Outline for task management chapter

Why manage your tasks in Emacs

- [ ] What you might be using now
  - [ ] Your brain
  - [ ] Paper
  - [ ] A text file
  - [ ] A sophisticated task management system
- [ ] The power of customization (tell a story)
- [ ] Integrating with your non-Emacs life

Strategies for task management

- [ ] Top-down
- [ ] Bottom-up
- [ ] Combining both strategies
- [ ] The daily and weekly reviews

Choosing a task manager

- [ ] Outline-oriented planning, dynamic views
- [ ] Day orientation, more flexibility in prioritizing individual tasks, publishing, sharing additional information

Org

- [ ] A day in the life
- [ ] The basics
  - [ ] Working with tasks
  - [ ] Viewing your task list
  - [ ] Prioritizing tasks
  - [ ] Scheduling tasks
  - [ ] Viewing your agenda
  - [ ] Marking a task as done
  - [ ] Weekly reviews
- [ ] Intermediate topics
  - [ ] Clocking time
  - [ ] Repeating tasks
  - [ ] Working with projects
  - [ ] Working with tags
- [ ] Advanced stuff
  - [ ] Managing multiple identities
  - [ ] Estimating your time
  - [ ] Publishing your task list
    - [ ] Twitter task updates
    - [ ] Daily task list
    - [ ] Project summary

Planner

- [ ] A day in the life
- [ ] The basics
  - [ ] Working with tasks
  - [ ] Viewing your task list for the day
  - [ ] Prioritizing tasks
  - [ ] Scheduling tasks
  - [ ] Marking a task as done
  - [ ] Weekly reviews
- [ ] Intermediate topics
  - [ ] Clocking time
  - [ ] Working with plan pages
  - [ ] Task overviews
  - [ ] Repeating tasks
- [ ] Advanced stuff
  - [ ] Estimating your time
  - [ ] Publishing your task list
    - [ ] Private information in your tasks
    - [ ] Twitter task updates
    - [ ] Daily task list
    - [ ] Project summary

Wrapping up

On Technorati: , ,

Random Emacs symbol: appt-display-format – Variable: How appointment reminders should be displayed.

Why I use Emacs to manage my tasks

I’m writing a chapter on how to use Emacs to manage your tasks. I find it hard to explain why Emacs is so compelling.

I’ve tried all sorts of other task manager before. I used Lotus Organizer, Microsoft Outlook, and Lotus Notes. I’ve tried iPaqs and Palms. I’ve tried Tada List and Remember the Milk (which has an interesting Gmail plugin). I’ve seen people use Life Balance. Heck, I’ve even done the Hipster PDA, index cards, Moleskine hacks, and bits of paper (which I always ended up losing).

I keep coming back to my Emacs.

Day after day, year after year, it’s the only system I’d trust with my plans. (Yes, I trust Emacs with my life. Meep! I’ve really gone off the deep end, haven’t I?)

Why? I spent some time talking things through last night, trying to get to the bottom of the reason why Emacs works for me and why it might work for other people. (Well, I was talking to myself and using a voice recorder, as my significant other is a fan of the Other Editor.)

Why Emacs?

  • For the ease of working with text files? I hate using the mouse, and I’ve loved being able to quickly review, reorganize, and check off tasks with keyboard shortcuts. I can back up the text files and not worry about anything getting corrupted. I can put in practically anything I want.
  • For the ability to automatically pick up information, such as a hyperlink back to the source? I can create tasks that are automatically hyperlinked to e-mail, contact records, web pages, files… whatever I’m looking at. This was _really_ handy back when I did my work-related e-mail in Emacs as well, because I could jump back to the original message quickly.
  • For the customizability? It still boggles me that you can’t just redefine the keyboard shortcuts for all applications. I love customizing things to fit my idiosyncrasies.
  • For the interoperability? I love how I can pull together different modules. For example, I had the crazy idea of hooking my task manager to Twitter, just for fun. I wrote a little code to combine twit.el and org.el, and it jus worked.

Hmm. Those last two things there are interesting, because they’re _so_ difficult to demonstrate when people are looking at my computer. Or when I’m writing a book, for that matter.

It’s not just about the freedom to customize it. Many programmers’
development environments are customizable. What’s great—no,
transformational—about task management in Emacs is that each
customization encourages you to explore even more. Here’s how that works:

  • Think of a better way to do things.
  • (Look for people who have done that before. Discover several similar things. Write about your idea on the mailing list. Get other ideas from people.)
  • Make it happen in code. This frees up your brain and inspires you to think of other crazy ideas.

I think what’s really amazing is that you get _used_ to this process.
You get a crazy idea, you build it in, you’re happy about the hack,
and you’re free to think of other crazy ideas. More than that, you
give your brain permission to think of crazy ideas, because you can
actually make it happen. And you get used to thinking about how you do
things, looking for ways to do things better. And you get used to
talking about things with other people who are also looking for ways
to do things better.

How do I make this process clearer for people? How do I show people
how amazing it is to consciously work on being more effective,
together with other geeks who are doing similar things?

On Technorati: ,

Random Emacs symbol: w3m-list-buffers – Function: Return a list of buffers in which emacs-w3m sessions are open.

A day in a life with Org

I spend most of my day working on or near a computer: writing,
replying to e-mail, making phone calls, and so on. I use Lotus Notes
for my calendar because people need to be able to check my
availability for meetings. I use Emacs to keep track of what I need to
do, because it makes planning my day so much easier.

The first thing I do each morning is quickly go through my e-mail
looking for action items. Instead of leaving them in my mail inbox, I
create tasks for each of the items in my Org to-do list. I add notes
so that I don’t have to find the e-mails again. I also add other tasks
that come to mind. I add time estimates whenever I can.

This step is also a good time to review my personal objectives and
proactively set myself some tasks so that I can move towards them. For
example, if I want to learn more about career growth, I can’t wait for
e-mail from someone else telling me what to do. I have to think of
something to do, and build time into my day in order to do it. I put
all those tasks into my task inbox, which is just a header at the
bottom of my task list, like this:

(remove the leading space)

 * Inbox
 ** TODO ....
 ** TODO ....

Now that I’ve captured all these tasks, I review my day. What are my
appointments? What items are due today? I double-check this against
my official calendar to make sure I haven’t missed any
appointments. After I make sure that the important tasks and
appointments are there, I start filling in gaps, scheduling some of my
important-but-not-urgent tasks onto today.

After I’ve decided what to do that day, I review the rest of the
week. Does my workload look reasonable? Are there upcoming deadlines?
I try to make sure that all of my inbox items have scheduled dates. I
also review my list of waiting tasks to see if I need to follow up
with anyone.

After I’ve gotten the tasks all down and scheduled, it’s easy to
organize them under the appropriate headings. Billable tasks are filed
under the projects they belong to, and unbilled tasks are categorized
by how I need to report them and how I organize them into personal
projects. Organizing tasks into categories AFTER I schedule them means
less jumping around looking for unscheduled tasks.

This process (e-mail scan and daily and weekly overview) takes me
around 15 minutes, and helps keep me sane.

I try to keep my mornings free for creative brainstorming and heavy
lifting. Once I’ve reviewed my plans for the day and the week, I pick
a task and work on it for an hour or so. When I mark the task as
STARTED (“t” or “C-u t” from the Org agenda view), the clock
automatically starts ticking. When I mark the task as WAITING or DONE,
the clock automatically stops. Org timeclocking makes it easier for me
to report my hours at the end of each week. I can also compare the
actual times against my estimates, helping me improve my accuracy.

This process is my morning ritual: putting tasks into my Org agenda,
organizing them, reviewing and planning from my calendar, and then
getting started by working on something useful _before_ I spend time
catching up with the blogosphere or responding to my mail. It’s
complemented by my afternoon ritual of reviewing my completed tasks
with the Org agenda logbook and possibly blogging about some lessons
learned.

Here’s how you can use Org to do the same, assuming that you’ve set it
up already.

Morning ritual:

*Read your e-mail and create tasks.* Open your Org file. If it’s not yet in your Org agenda list, add it with C-c [ (org-agenda-file-to-front).

You can jump to the end of the file using M-> (end-of-buffer) and
add tasks just by typing "** TODO " and the task name. If you read
e-mail in Emacs (and there are plenty of good reasons to do so!), you
can set up Remember Mode to make it easy to create hyperlinked tasks
from mail and other sources. Use C-c C-d (org-deadline) to note
deadlines for the current task, and use C-c C-s (org-schedule) to note
when a task needs to be done on a certain date.

*Review your projects and create tasks.* Tag projects like this:

 ** Learn about career options within the company     :PROJECT:

Then you can use a custom agenda view to see your agenda for today, your projects, and other useful information.
Here's something you can add to your ~/.emacs:

(global-set-key (kbd "C-c a") 'org-agenda)
(setq org-agenda-custom-commands
      '(("a" "My custom agenda"
	 ((org-agenda-list nil nil 1)
	  (tags "PROJECT-WAITING")
	  (tags-todo "WAITING")
	  (tags-todo "-MAYBE")))))

You can then use C-c a a (org-agenda, custom command) to get an overview of your day/week, your
current projects, your WAITING tasks, and your active tasks.

*Review your day.* Use C-c a a (org-agenda, custom command) to see
your appointments for the day, and open your Org file in another
buffer. Use C-c C-s (org-schedule) in your Org file to schedule some
of your inbox tasks for the day and some of your tasks for other days
in the week. You can use Shift-right and Shift-left to reschedule
tasks from the agenda view. Use "w" in the agenda to switch to a
weekly view, and "d" to switch to a daily view.

If you want to see how your time estimates fit into your workday with
a load estimate like this:

15.8% load: 90 minutes to be scheduled, 570 minutes free, 480 minutes gap

add estimated number of minutes to your tasks like this:

** TODO 60 Browse through a book
** TODO 15 Scan my RSS feeds

and use the following code in your ~/.emacs:

(defun sacha/org-show-load ()
  "Show my unscheduled time and free time for the day."
  (interactive)
  (let ((time (sacha/org-calculate-free-time
               ;; today
               (calendar-gregorian-from-absolute (time-to-days (current-time)))
               ;; now
               (let* ((now (decode-time))
                      (cur-hour (nth 2 now))
                      (cur-min (nth 1 now)))
                 (+ (* cur-hour 60) cur-min))
               ;; until the last time in my time grid
               (let ((last (car (last (elt org-agenda-time-grid 2)))))
                 (+ (* (/ last 100) 60) (% last 100))))))
    (message "%.1f%% load: %d minutes to be scheduled, %d minutes free, %d minutes gap\n"
            (/ (car time) (* .01 (cdr time)))
            (car time)
            (cdr time)
            (- (cdr time) (car time)))))

(defun sacha/org-agenda-load (match)
  "Can be included in `org-agenda-custom-commands'."
  (let ((inhibit-read-only t)
        (time (sacha/org-calculate-free-time
               ;; today
               (calendar-gregorian-from-absolute org-starting-day)
               ;; now if today, else start of day
               (if (= org-starting-day
                      (time-to-days (current-time)))
                   (let* ((now (decode-time))
                          (cur-hour (nth 2 now))
                          (cur-min (nth 1 now)))
                     (+ (* cur-hour 60) cur-min))
                 (let ((start (car (elt org-agenda-time-grid 2))))
                   (+ (* (/ start 100) 60) (% start 100))))
                 ;; until the last time in my time grid
               (let ((last (car (last (elt org-agenda-time-grid 2)))))
                 (+ (* (/ last 100) 60) (% last 100))))))
    (goto-char (point-max))
    (insert (format
             "%.1f%% load: %d minutes to be scheduled, %d minutes free, %d minutes gap\n"
             (/ (car time) (* .01 (cdr time)))
             (car time)
             (cdr time)
             (- (cdr time) (car time))))))

(defun sacha/org-calculate-free-time (date start-time end-of-day)
  "Return a cons cell of the form (TASK-TIME . FREE-TIME) for DATE, given START-TIME and END-OF-DAY.
DATE is a list of the form (MONTH DAY YEAR).
START-TIME and END-OF-DAY are the number of minutes past midnight."
  (save-window-excursion
  (let ((files org-agenda-files)
        (total-unscheduled 0)
        (total-gap 0)
        file
        rtn
        rtnall
        entry
        (last-timestamp start-time)
        scheduled-entries)
    (while (setq file (car files))
      (catch 'nextfile
        (org-check-agenda-file file)
        (setq rtn (org-agenda-get-day-entries file date :scheduled :timestamp))
        (setq rtnall (append rtnall rtn)))
      (setq files (cdr files)))
    ;; For each item on the list
    (while (setq entry (car rtnall))
      (let ((time (get-text-property 1 'time entry)))
        (cond
         ((and time (string-match "\\([^-]+\\)-\\([^-]+\\)” time))
          (setq scheduled-entries (cons (cons
                                         (save-match-data (appt-convert-time (match-string 1 time)))
                                         (save-match-data (appt-convert-time (match-string 2 time))))
                                        scheduled-entries)))
         ((and time
               (string-match “\\([^-]+\\)\\.+” time)
               (string-match “^[A-Z]+ \\(\\[#[A-Z]\\]\\)? \\([0-9]+\\)” (get-text-property 1 ‘txt entry)))
          (setq scheduled-entries
                (let ((start (and (string-match “\\([^-]+\\)\\.+” time)
                                 (appt-convert-time (match-string 1 time)))))
                  (cons (cons start
                              (and (string-match “^[A-Z]+ \\(\\[#[A-Z]\\]\\)? \\([0-9]+\\) ” (get-text-property 1 ‘txt entry))
                                   (+ start (string-to-number (match-string 2 (get-text-property 1 ‘txt entry))))))
                        scheduled-entries))))
         ((string-match “^[A-Z]+ \\([0-9]+\\)” (get-text-property 1 ‘txt entry))
          (setq total-unscheduled (+ (string-to-number
                                      (match-string 1 (get-text-property 1 ‘txt entry)))
                                     total-unscheduled)))))
      (setq rtnall (cdr rtnall)))
    ;; Sort the scheduled entries by time
    (setq scheduled-entries (sort scheduled-entries (lambda (a b) (< (car a) (car b)))))

    (while scheduled-entries
      (let ((start (car (car scheduled-entries)))
            (end (cdr (car scheduled-entries))))
      (cond
       ;; are we in the middle of this timeslot?
       ((and (>= last-timestamp start)
             (< = last-timestamp end))
        ;; move timestamp later, no change to time
        (setq last-timestamp end))
       ;; are we completely before this timeslot?
       ((< last-timestamp start)
        ;; add gap to total, skip to the end
        (setq total-gap (+ (- start last-timestamp) total-gap))
        (setq last-timestamp end)))
      (setq scheduled-entries (cdr scheduled-entries))))
    (if (< last-timestamp end-of-day)
        (setq total-gap (+ (- end-of-day last-timestamp) total-gap)))
    (cons total-unscheduled total-gap))))

Then you can add it to your custom agenda by using this in your ~/.emacs:

;; Change your existing org-agenda-custom-commands
(setq org-agenda-custom-commands
      '(("a" "My custom agenda"
	 ((org-agenda-list nil nil 1)
          (sacha/org-agenda-load)    ; ADD THIS LINE
	  (tags "PROJECT-WAITING")
	  (tags-todo "WAITING")
	  (tags-todo "-MAYBE")))))

*Organize your inbox.* Now that you've scheduled your tasks, move them
under the appropriate headings. You can use TAB to collapse a task
into a single line, then C-k (kill-line) to cut it and C-y to paste it
elsewhere. I like using C-r (isearch-backward) to search for the right
place in the file.

*Get to work!* You may find it useful to have four states for a task: TODO, STARTED, WAITING, and DONE.
It's also handy to type in a note when you mark a task as done. To set that up, just add the following to the beginning of your Org file:

#+STARTUP: lognotedone
#+SEQ_TODO: TODO STARTED WAITING DONE

Then you can use "t" (org-todo) from the Org agenda view or C-c C-t
(org-todo) from the Org file to mark a TODO task as STARTED, or to
move from one state to the other. To move to a specific state (DONE
from STARTED, for example), either edit it directly or use C-u before
the org-todo command.

Use the following code to automatically clock in when you start a
task, start a task when you clock in, and clock out of a task when you
mark it as waiting.

(defun sacha/org-clock-in-if-starting ()
  "Clock in when the task is marked STARTED."
  (when (and (string= state "STARTED")
             (not (string= last-state state)))
    (org-clock-in)))
(add-hook 'org-after-todo-state-change-hook
	  'sacha/org-clock-in-if-starting)
(defadvice org-clock-in (after sacha activate)
  "Set this task's status to 'STARTED'."
  (org-todo "STARTED"))

(defun sacha/org-clock-out-if-waiting ()
  "Clock in when the task is marked STARTED."
  (when (and (string= state "WAITING")
             (not (string= last-state state)))
    (org-clock-out)))
(add-hook 'org-after-todo-state-change-hook
	  'sacha/org-clock-out-if-waiting)

*Review your accomplishments at the end of the day.* You can use the
Org agenda logbook to see all your completed tasks. From an Org agenda
view such as the custom one you set up for C-c a a, type "l"
(lowercase L). You can then see your completed TODOs.

To review your time usage, you can use C-c C-x C-d (org-clock-display)
from an Org buffer to see time totals according to the tree, or you
can add a table to your custom agenda view. Add the following to your
~/.emacs:

(defun sacha/org-agenda-clock (match)
  ;; Find out when today is
  (let* ((inhibit-read-only t))
    (goto-char (point-max))
    (org-dblock-write:clocktable
     `(:scope agenda
       :maxlevel 4
       :tstart ,(format-time-string "%Y-%m-%d" (calendar-time-from-absolute (1+ org-starting-day) 0))
       :tend ,(format-time-string "%Y-%m-%d" (calendar-time-from-absolute (+ org-starting-day 2) 0))))))

and then add sacha/org-agenda-clock to your custom agenda in
org-agenda-custom-commands in your ~/.emacs file, like this:

;; Change your existing org-agenda-custom-commands
(setq org-agenda-custom-commands
      '(("a" "My custom agenda"
	 ((org-agenda-list nil nil 1)
          (sacha/org-agenda-load)
          (sacha/org-agenda-clock)    ; Add this line
	  (tags "PROJECT-WAITING")
	  (tags-todo "WAITING")
	  (tags-todo "-MAYBE")))))

You can then use C-c a a (org-agenda, custom command) to see a table summarizing your clocked-in time for that day.

END RESULT: You can add tasks, quickly get an overview of your day and
week, reschedule tasks until you've got a realistic load, keep track
of your progress, and review your accomplishments.

Org keeps me sane. =) The code above only looks like a lot of customization, but it's well worth it.

Next, I'm going to figure out how to calculate my velocity, or estimated time divided by actual time taken... =)

(Thanks to Pete Bevin for catching a typo! =) )

On Technorati: , , , ,

Random Emacs symbol: floor - Function: Return the largest integer no greater than ARG.

One day with Planner

The daily rituals I described yesterday can also be done with Planner, another personal information manager for Emacs. In fact, I spent about four years managing my tasks using Planner before I tried out Org. My process then was similar to my Org process now in that I wrote the tasks down before I tried to organize or do them, and I built in some time for a review. The difference was that I didn’t organize most of my tasks into separate projects (or plan pages, as Planner calls them). Instead, I tended to organize them according to day. This was helpful when publishing my blog, as I could post my task list along with it. I also liked the greater control I had over my daily task list, and I often used blank lines or extra notes to keep things organized.

The core of the process was the same, though:

  1. Get the tasks out of your head.
  2. Schedule the tasks.
  3. Do the tasks.
  4. Review the tasks.

Get the tasks out of your head

The first thing I did each day was to put all of my tasks into my
Planner. I briefly scanned through my mail looking for action items,
and whenever I found something I needed to do that would take more
than two minutes, I created a task for it using
planner-create-task-from-buffer. This automatically created a
hyperlink back to the e-mail or file I was reading, and included
useful information such as the e-mail author.

I treated appointments just like tasks, although I added a timestamp
like @13:00 to make it easier to see and sort my appointments.

planner-create-task-from-buffer helped me keep track of reactive
tasks, or things that I needed to do because someone else asked me to
do them. However, I also made a point of reviewing my goals and making
up my own tasks so that I could work on my personal projects. For
example, I had a plan page where I put all my writing ideas, and I
added those tasks to today’s page once in a while.

I also scanned the last few day pages to see if I’d missed anything,
and the next few days to see if I needed to plan for anything.
Although the M-x plan command automatically brings tasks forward, I
didn’t use it to start my day. Instead, I reviewed the last three days
or so, marking tasks that I’d completed but not updated, cancelling
tasks I no longer wanted or needed to do, and rescheduling other tasks
forward using C-c C-c (planner-copy-or-move-task). I also reviewed the
next three days or so. C-c C-j C-y (planner-goto-yesterday) and C-c
C-j C-t (planner-goto-tomorrow) were handy for flipping through pages.
To make the shortcuts shorter and more natural, I bound them to F9 F8
and F9 F10 with:

(global-set-key (kbd "<f9> <f8>") 'planner-goto-yesterday)
(global-set-key (kbd "<f9> <f10>") 'planner-goto-tomorrow)

At the end of this step, I had all the things I needed to do scheduled
for today.

So the first thing you need to do is get used to creating tasks
quickly. Get them out of your head and into Planner, where you can
then schedule, organize, act on, and review them. You can bind
planner-create-task-from-buffer to a convenient shortcut key such as
C-c t SPC by using the following code in your ~/.emacs:

(global-set-key (kbd "C-c t SPC") 'planner-create-task-from-buffer)

By default, planner-create-task-from-buffer asks you for a date and a
plan page when you create tasks. You can either slow down and think
about this, hit RET twice to accept the defaults, or modify Planner so
that it doesn’t prompt you at all. Being lazy, I chose to let Planner
put all the tasks on today’s page and a copy on the TaskPool plan page
for backup. If I knew I had to do something on a specific date, I
could tell it to prompt for the date by using the prefix argument (C-u
before the command).

Here’s the code that makes that happen:

(defun sacha/planner-read-task ()
  "Do not prompt for date unless the prefix argument is given."
  (let ((planner-expand-name-favor-future-p t))
    (list (read-string "Describe task: ")
          (if current-prefix-arg (planner-read-date) (planner-today))
          "TaskPool"
          planner-default-task-status)))
(defalias 'planner-read-task 'sacha/planner-read-task)

Organize the tasks

Getting the tasks out of my head often resulted in a long list of
tasks, not all of which I needed to do or could even do that day. Then
it was time to ruthlessly use C-c C-c (planner-copy-or-move-task) and
M-x planner-copy-or-move-region to trim my task list down to a
manageable size. I moved tasks that didn’t need to be done on a
certain date to the TaskPool, which I checked whenever I had some free
time.

If I wanted to assign a task to a specific time, I just added a
timestamp such as @14:30 to the task. I had some code which
automatically sorted the tasks by time, so it would go to the right
place.

I also used M-down and M-up (planner-lower-task and
planner-raise-task) to move tasks around. To visually group tasks, I
added blank lines and explanatory text. For example, I put errands
together and I moved the tasks up and down into a logical order for
doing things.

If there were a lot of small items in my day, I also separated the
“must-be-dones” from the “nice-to-dos”. This wasn’t related to the
importance of the task, just the urgency. Urgent items went in the
first group, and non-urgent items went in the second group of tasks.

At the end of this step, I had a daily plan page which showed me my
tasks and appointments for the day, in the rough order in which I
planned to do them. I also had some tasks on future days, and some
tasks in my TaskPool.

Do the tasks

Now that all my tasks were on the page, it was easy to go through
them. To start working on a task, I marked it as in-progress with C-c
C-i (planner-task-in-progress). If I needed to postpone it, I used C-c
C-p (planner-task-pending). To mark it finished, I used C-c C-x
(planner-task-done). To mark it cancelled, I used C-c C-S-x
(planner-task-cancelled; does not work in some terminals).

Because I had loaded planner-timeclock.el using code like this:

(require 'planner-timeclock)

the clock automatically started when I marked tasks as in-progress and stopped when I marked tasks as pending or done. I could also clock out of a task manually by using C-c C-o (timeclock-out).

Review the tasks

To review what I did that day, all I had to do was go to the day page using planner-goto-today, which I bound to F9 F9 with:

(global-set-key (kbd "<f9> <f9>") 'planner-goto-today)

I checked my timeclock reports with M-x planner-timeclock-summary-show, which gave me reports that looked like this:

Timeclock summary report for 2007.11.25

Project     | Time     | Ratio  | Task
Not Planned |  0:28:38 | 38.6%  | Do weekly review
.           |  0:45:37 | 61.4%  | Figure out how to set up syndicated blog on WordPress
Total:      |  1:14:15 | 100.0% | .


Day began: 21:01:20, Day ended: 22:16:06
Time elapsed: 1:14:46, Time clocked: 1:14:15
Time clocked ratio: 99.3%

It’s easy to configure planner-timeclock-summary to add that report to
day pages automatically, but I rarely checked my time usage then, so I
didn’t set that up. I also didn’t usually need to see my time summary
for a particular project, but you could get that with
planner-timeclock-summary-proj.el.

So at the end of this step, I had a warm and fuzzy feeling from seeing
many checked-off tasks on my task list. I published my task list to
the Net, too, which made it easy for other people to keep up to date
with what I was doing. Good stuff.

Planner helped me keep track of the different things I wanted to do.
Working with the other Planner geeks was also an incredible
experience. I’ve switched to Org for my task management because Org
does timeclocking better, but I still miss being able to easily
organize, publish, and tweak my daily task list. =) If you’re new to Emacs planning, I suggest giving both OrgMode and PlannerMode a try!

On Technorati: , ,

Get a grip on your tasks

Most time management books will tell you to think of your three- to
five-year goals, come up with projects, and then make tasks based on
those projects.

You know that life doesn’t happen as neatly as that. Instead, tasks
come at you from all sides: the bugs you discover while you read code,
the e-mails you get from coworkers, the milk that you need to pick up
on the way home. The task list just keeps getting bigger.

I want to help you set up Emacs so that it will:

  • capture all those tasks so that you don’t worry about forgetting anything,
  • show you what you need to do so that you can work effectively,
  • help you organize your day, your week, your life,
  • show you what you’ve accomplished so that you have a feeling of progress,
  • help you plan the things that _you_ want to do, and
  • fit the way _you_ want to work, whether that’s Franklin-Covey, GTD, or a home-brew system for keeping sane.

If you’ve been keeping your task list in your head, you’ll find it
immensely helpful to get it out and into your computer. If you swear
by your day planner or index cards, you might find that Emacs is not
only a good backup, but it can also give you an overview of where
you’re going and where you’ve been. If you need to bill for your time,
you’ll love how time tracking is integrated into your task list. And
even if you’ve never written a line of Emacs Lisp before, you might
find that customizing Emacs to fit the way you think will *transform*
the way you think.

Give it a try. Use Emacs to manage your tasks for a month. Write
everything down in it. Use it to run your life. At the end of the
month, if it doesn’t feel natural to you, at least you can say that
Emacs really isn’t just an editor, it’s a way of life. It might not be
_your_ way of life, but you’ll have learned something from it,
guaranteed.

In this chapter, you will learn how to:

  • Plan from your projects (top-down)
  • Plan from your task list (bottom-up)
  • Schedule the tasks
  • View your schedule and tasks
  • Organize the tasks into projects
  • Track your time
  • Review your accomplishments

Let’s get started!

(This is a draft for my book, “Wicked Cool Emacs”. See other Wicked Cool Emacs blog entries.)

On Technorati: , ,

Random Emacs symbol: gnus-summary-number-of-articles-in-thread -
Function: Return the number of articles in THREAD.