Category Archives: wickedcoolemacs

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 ( 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


- [ ] 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


- [ ] 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-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."
  (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."
  (let ((files org-agenda-files)
        (total-unscheduled 0)
        (total-gap 0)
        (last-timestamp start-time)
    (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)))
         ((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))))
         ((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))))))
         ((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)))
      (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))))
       ;; 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-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

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)))
(add-hook 'org-after-todo-state-change-hook
(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)))
(add-hook 'org-after-todo-state-change-hook

*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))
     `(: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-clock)    ; Add this line
	  (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))
(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.