Category Archives: notetaking

On this page:

The dawn of a new Moleskine

I’ve reached the last page on my well-loved Moleskine notebook and
must retire it to my archives. This is the little black notebook I
described in my blog post on
Networking with Moleskines. I have a fresh Moleskine to write in, newly numbered (odd pages only)
and ready for all the conversations I’ll have in the future. I’ve moved my masking-tape fountain pen holder to the new Moleskine.

It’s a good time to think about what I’d like to keep and what I’d
like to change.

I’ve come to see my notebook as a temporary buffer for conversations,
notes, promises, thoughts, ideas – anything that should make its way
into my computer. It performs this job admirably. It’s the only way I
can remember to keep in touch with so many people after all the events
I go to. It lets me be proactive in following up. Of course, it’s not
much good if I don’t actually have the time to sit down and do some
correspondence, but at least the data is kept somewhere safe.

I love the back pocket – great for business cards and emergency cash.
I love the binding. I love the fountain pen’s heft in my hand and the
smoothness with which it glides across the cream paper. I love the
comments and smiles I get when people notice the pen, too. I love the
secret knowing grins of fellow members of the Moleskine cult. ;)

Most of all, I love the trust. I love knowing that everything would be
in my little black book. All I have to do is go through everything
sequentially to make sure that I get everything into my computer and
my Big Brother Database.

TO KEEP:

  • Paper is good.
  • Using my notebook for conversations is terrific.
  • I should keep some kind of index for memorable information. I referred to this frequently.

TO CHANGE:

  • No ripping things out. Ever.
  • Need better way to keep track of what’s already in my computer, what’s been acted on, etc.
  • Need better way to scan backwards for a previous mention of someone. Episodic memory is my friend.
  • Add occasional to-blog pages with back and forward references.
  • Use colored tabs, perhaps?
  • Need some kind of picture support, maybe with phone?

How to make a complete map of every thought you think

Michael Nielsen is also responsible for telling me about How to Make a Complete Map of Every Thought you Think, a book about the clarity that comes when you record everything you think. That’s way more than I’m doing right now. Fascinating, though! More about this after I read the book. Random Emacs symbol: apropos-sort-by-scores – Variable: *Non-nil means sort matches by scores; best match is shown first.

Note-taking: Random notes, journal entries, outlines, and hyperlinks

I take at least three different kinds of notes, and I need to manage them differently. Here are some rough thoughts on the different kinds of notes I work with and how I manage them. I’d love to hear about your note-management strategies in comments or e-mail!

Random notes

When I worked on my thesis, I filed hundreds of lines from my literature review. I needed to quickly pull together just the notes matching a certain keyword or belonging to a particular section. I also needed to be able to properly cite each note. Lastly, I structured my notes so that I could get a random note, which turned out to be really helpful for breaking me out of writing ruts and for helping me see creative connections.

Writers and public speakers keep similar databases of story ideas and great quotations. They need to be able to search their databases for matching records, and they might not think of these categories ahead of time.

Random information management isn’t just for word geeks and researchers. If you’ve got scraps of paper or a text file with notes from meetings, clips from interesting articles, and thoughts to yourself, you’re already managing random information. You just might not have a good system for capturing and searching the information.

Important things for a random information manager:

  • You should be able to easily capture information.
  • You should be able to easily search for information.

(An ideal random information manager might even suggest relevant entries.
Come to think of it, I should find out if I can get the Remembrance Agent running again. That was really cool.)

I started using Howm for this before. It was a great random information manager for Emacs. I haven’t been using it lately, though, as I hadn’t set it up on my work laptop. I might do so soon.

Journal entries

Journal entries tend to be short, chronological notes. They can be private or public, or a mix of both. They can be also be retrospective or forward-looking. Journal entries are more structured than random information snippets because they’re associated with a specific date and are generally about activities, experiences, or goals.

My blog is an example of a journal. It has public and private entries. The private entries are removed from the blog before publishing.

Important things for a journal manager or a blog:

  • You shouldn’t have to enter date and time yourself.
  • You should be able to flip through your entries or search them for keywords.
  • You should be able to get an overview of your notes for a time period.

I use Planner for this because Planner makes it easy to publish day pages and RSS. I also write some entries directly on a WordPress blog, which also imports my Planner blog entries.

Outlines

Some notes belong to a bigger structure. For example, if you’re drafting a document, you might work on different sections that will ultimately be merged. Random information management and journals are not enough because you need structure. An outline helps you see how things fit together.

The draft for this book is an example of an outline. I sometimes work top-down by starting with the headings and defining more detail. I also work bottom-up by writing blocks of content and then fitting them into my outline.

Important things for an outline:

  • You should be able to structure your notes into headings and subheadings.
  • You should be able to promote, demote, and rearrange those headings quickly.
  • You should be able to quickly get an overview or drill down into detail.

I use Org for outlined text because Org makes it really easy to manipulate outlines.

Hyperlinked Text

The structure of hyperlinked text can actually be applied to the other three types of notes. Random notes benefit from freely-defined hyperlinks, where you can specify keywords that will automatically be linked without needing to edit each note where the keyword occurs. Journal entries can link to other journal entries or to topic-oriented pages. Outlines and other documents may allow people to jump to related sections through hyperlinks. Hyperlinks allow you to work with more freedom than a strict hierarchy of topics would permit.

An example of a hyperlinked note system would be the way the posts on my blog are often linked with plan pages that focus on specific topics. (These links are only on my hard disk, so don’t worry if you don’t see them!) Topic pages allow me to review my topic-related notes as well as other freeform notes I’ve added.

Important things for hyperlinks:

  • You should be able to link to resources outside the note-taking system.
  • You should be able to link to other notes in the note-taking system.
  • You may want to be able to link to other sections of the same note.

I tend to use Muse with Planner for hyperlinked pages, but I’ve also tried it with Howm.

Search

A note-taking system good at capturing journal entries may not necessarily be good at capturing and searching random information or managing outlines. It helps to have different note-taking systems, each optimized for different tasks, or a tool that adapts to what you need at that time. A search that spans your different note-taking systems is also a great help.

Currently, I don’t have a unified search system. Well, aside from grep… This is one of the things I plan to work on while writing this chapter. =)

Feedback?

Do you keep other types of notes, and/or do you have tips for managing notes? Please share them here so that I can think about how Emacs can be tweaked to support them!

Outlining Your Notes with Org

Large documents are almost impossible to write without outlines.  There’s just too much to fit in your head. Outlines help you work with a structure, so that you can see the big picture and how sections fit together. Outlines are also surprisingly useful when brainstorming. You can work with varying levels of detail, starting with a high-level overview and successively refining it, or starting with the details and then letting the structure emerge as you organize those details into groups.

Emacs has one of the most powerful outline editors I’ve come across. Although word processors like Microsoft Word and OpenOffice.org Writer support outlines too, Emacs has a gazillion keyboard shortcuts, and once you get the hang of them, you’ll want them in other applications as well. In addition, working in Emacs tends to force you to focus on the content instead of spending time fiddling with the formatting. Whether you’re writing personal notes or working on a document that’s due tomorrow, this is a good thing.

In this section, you’ll learn how to outline a document using Org. You’ll be able to create headings, sub-headings, and text notes. You’ll also learn how to manage outline items by promoting, demoting, and rearranging them.

Understanding Org

Org is primarily a personal information manager that keeps track of your tasks and schedule, and you’ll learn more about those features in chapters 8 and 9. However, Org also has powerful outline-management tools, which is why I recommend it to people who want to write and organize outlined notes.

The structure of an Org file is simple: a plain text file with headlines, text, and some additional information such as tags and timestamps. A headline is any line that stars with a series of asterisks. The more asterisks there are, the deeper the headline is. A second-level headline is the child of the first-level headline before it, and so on. For example:

* This is a first-level headline
Some text under that headline
** This is a second-level headline
Some more text here
*** This is a third-level headline
*** This is another third-level headline
** This is a second-level headline

Because Org uses plain text, it’s easy to back up or process using scripts. Org’s sophistication comes from keyboard shortcuts that allow you to quickly manipulate headlines, hide and show outline subtrees, and search for information.

GNU Emacs 22 includes Org. To automatically enable Org mode for all files with the .org extension, add the following to your ~/.emacs:

(require 'org)
(add-to-list 'auto-mode-alist '("\\.org$" . org-mode))

To change to org-mode manually, use M-x org-mode while viewing a file. To enable Org on a per-file basis, add

-*- mode: org -*- 

to the first line of the files that you would like to associate with Org.

Working with Outlines

You can keep your notes in more than one Org file, but let’s start by creating ~/notes.org. Open ~/notes.org, which will automatically be associated with Org Mode. Type in the general structure of your document. You can type in something like this:

 * Introduction
 * ...

You can also use M-RET (org-meta-return) to create a new headline at the same level as the one above it, or a first-level headline if the document doesn’t have headlines yet.

Create different sections for your work. For example, a thesis might be divided into introduction, review of related literature, description of study, methodology, results and analysis, and conclusions and recommendations. You can type in the starting asterisks yourself, or you can use M-RET (org-meta-return) to create headings one after the other.

Now that you have the basic structure, start refining it. Go to the first section and use a command like C-o (open-line) to create blank space. Add another headline, but this time, make it a second-level headline under the first. You can do that by either typing in two asterisks or by using M-RET (org-meta-return, which calls org-insert-heading) and then M-right (org-metaright, which calls org-do-demote). Then use M-RET (org-meta-return; org-insert-heading) for the other items, or type them in yourself. Repeat this for other sections, and go into as much detail as you want.

What if you want to reorganize your outline? For example, what if you realized you’d accidentally put your conclusions before the introduction? You could either cut and paste it using Emacs shortcuts, or you can use Org’s outline management functions. The following keyboard shortcuts are handy:

Action Command Shortcut Alternative
Move a subtree up org-metaup / org-move-subtree-up M-up C-c C-x u
Move a subtree down org-metadown / org-move-subtree-down M-down C-c C-x d
Demote a subtree org-shiftmetaright / org-demote-subtree S-M-right C-c C-x r
Promote a subtree org-shiftmetaleft / org-promote-subtree S-M-left C-c C-x l
Demote a headline org-metaright / org-do-demote M-right C-c C-x <right>
Promote a headline org-metaleft / org-do-promote M-left C-c C-x <left>
Collapse or expand a subtree org-cycle (while on headline) TAB  
Collapse or expand everything org-shifttab (org-cycle) S-TAB C-u TAB

Use these commands to help you reorganize your outline as you create a skeleton for your document. These commands make it easy to change your mind about the content or order of sections. You might find it easier to sketch a rough outline first, then gradually fill in more and more detail. On the other hand, you might find it easier to pick one section and keep drilling it down until you have headlines some seven levels deep. When you reach that point, all you need to do is add punctuation and words like "and" or "but" between every other outline item, and you’re done!

Well, no, not likely. You’ll probably get stuck somewhere, so here are some tips for keeping yourself going when you’re working on a large document in Org: brainstorming and getting a sense of your progress.

Brainstorming

Brainstorming is a great way to break your writer’s block or to generate lots of possibilities. The key idea is to come up with as many ideas as you can, and write them all down before you start evaluating them.

I usually switch to paper for mindmapping and brainstorming because paper helps me think in a more colorful and non-linear way. However, it can be hard to manage large mindmaps on paper, because you can’t reorganize nodes easily. Despite its text-heavy interface, Org is one of the best mindmapping tools I’ve come across. Because it’s built into Emacs, everything can be done through keyboard shortcuts.

When you’re brainstorming, you might like working from two different directions. Sometimes it’s easier to start with an outline and to add more and more detail. Other times, you may want to jot quick ideas and then organize them into groups that make sense. Org provides support for both ways of working.

Brainstorming bottom-up is similar to David Allen’s Getting Things Done method in that separating collection from organization is a good idea. That is, get the ideas out of your head first before you spend time trying to figure out the best way to organize them. To get things out of your head quickly, collect your ideas by using the M-RET (org-meta-return) to create a new heading, typing in your idea, and using M-RET (org-meta-return) to create the next heading. Do this as many times as needed.

One way to encourage yourself to brainstorm lots of ideas is to give yourself a quota. Charles Cave described this technique in an article on org-mode, and it’s a great way to use structure to prompt creativity. Simply start by adding a number of empty headings (say, 20), then work towards filling that quota. For example, you might start with ten blanks for ideas, then gradually fill them in like this:

* Things that make me happy
** Curling up with a good book
** Watching a brilliant sunset
** Giving or getting a big warm hug
** Writing a cool piece of Emacs code
** 
** 
** 
**
** 
**

When all of your ideas are in Org, start organizing them. This is where you move ideas around using M-S-up (org-shiftmetaup) and M-S-down (org-shift-metadown), which call org-move-subtree-up and org-move-subtree-down. This is also a good time to use headings to group things together.

Getting a Sense of Progress

You’ve brainstormed. You’ve started writing your notes. And if you’re working on a large document, you might lose steam at some point along the way. For example, while working on this book, I often find myself intimidated by just how much there is to write about Emacs. It helps to have a sense of progress such as the number of words written or the number of sections completed. To see a word count that updates every second, add this code to your ~/.emacs:

(defvar count-words-buffer
  nil
  "*Number of words in the buffer.")

(defun wicked/update-wc ()
  (interactive)
  (setq count-words-buffer (number-to-string (count-words-buffer)))
  (force-mode-line-update))
  
; only setup timer once
(unless count-words-buffer
  ;; seed count-words-paragraph
  ;; create timer to keep count-words-paragraph updated
  (run-with-idle-timer 1 t 'wicked/update-wc))

;; add count words paragraph the mode line
(unless (memq 'count-words-buffer global-mode-string)
  (add-to-list 'global-mode-string "words: " t)
  (add-to-list 'global-mode-string 'count-words-buffer t)) 

;; count number of words in current paragraph
(defun count-words-buffer ()
  "Count the number of words in the current paragraph."
  (interactive)
  (save-excursion
    (goto-char (point-min))
    (let ((count 0))
      (while (not (eobp))
	(forward-word 1)
        (setq count (1+ count)))
      count)))

The best way I’ve found to track my progress in terms of sections is to use a checklist. For example, the collapsed view for this section looks like this:

** Outline Notes with Org [7/9]    ;; (1)
*** [X] Outlining Your Notes...    ;; (2)
*** [X] Understanding Org...
*** [X] Working with Outlines...
*** [X] Brainstorming...
*** [ ] Getting a Sense of Progress... ;; (3)
*** [X] Searching Your Notes...
*** [X] Hyperlinks...
*** [X] Publishing Your Notes...
*** [ ] Integrating Remember with Org

  • (1): [7/9] shows that I’ve completed 7 of 9 parts.
  • (2): [X] indicates finished parts.
  • (3): [ ] indicates parts I still need to do.

This is based on the checklist feature in Org. However, the standard feature works only with lists like this:

*** Items [1/3]
- [X] Item 1
- [ ] Item 2
- [ ] Item 3

Add the following code to your ~/.emacs in order to make the function work with headlines:

(defun wicked/org-update-checkbox-count (&optional all)
  "Update the checkbox statistics in the current section.
This will find all statistic cookies like [57%] and [6/12] and update
them with the current numbers.  With optional prefix argument ALL,
do this for the whole buffer."
  (interactive "P")
  (save-excursion
    (let* ((buffer-invisibility-spec (org-inhibit-invisibility)) 
	   (beg (condition-case nil
		    (progn (outline-back-to-heading) (point))
		  (error (point-min))))
	   (end (move-marker
		 (make-marker)
		 (progn (or (outline-get-next-sibling) ;; (1)
			    (goto-char (point-max)))
			(point))))   
	   (re "\\(\\[[0-9]*%\\]\\)\\|\\(\\[[0-9]*/[0-9]*\\]\\)")
	   (re-box
	    "^[ \t]*\\(*+\\|[-+*]\\|[0-9]+[.)]\\) +\\(\\[[- X]\\]\\)")
	   b1 e1 f1 c-on c-off lim (cstat 0))
      (when all
	(goto-char (point-min))
	(or (outline-get-next-sibling) (goto-char (point-max))) ;; (2)
	(setq beg (point) end (point-max)))
      (goto-char beg)
      (while (re-search-forward re end t)
	(setq cstat (1+ cstat)
	      b1 (match-beginning 0)
	      e1 (match-end 0)
	      f1 (match-beginning 1)
	      lim (cond
		   ((org-on-heading-p)
		    (or (outline-get-next-sibling) ;; (3)
			(goto-char (point-max)))
		    (point))
		   ((org-at-item-p) (org-end-of-item) (point))
		   (t nil))
	      c-on 0 c-off 0)
	(goto-char e1)
	(when lim
	  (while (re-search-forward re-box lim t)
	    (if (member (match-string 2) '("[ ]" "[-]"))
		(setq c-off (1+ c-off))
	      (setq c-on (1+ c-on))))
	  (goto-char b1)
	  (insert (if f1
		      (format "[%d%%]" (/ (* 100 c-on)
					  (max 1 (+ c-on c-off))))
		    (format "[%d/%d]" c-on (+ c-on c-off))))
	  (and (looking-at "\\[.*?\\]")
	       (replace-match ""))))
      (when (interactive-p)
	(message "Checkbox statistics updated %s (%d places)"
		 (if all "in entire file" "in current outline entry")
		 cstat)))))
(defadvice org-update-checkbox-count (around wicked activate)
  "Fix the built-in checkbox count to understand headlines."
  (setq ad-return-value
	(wicked/org-update-checkbox-count (ad-get-arg 1))))

Now add [ ] or [X] to the lower-level headlines you want to track. Add [/] to the end of the higher-level headline containing those headlines. Type C-c # (org-update-checkbox-count) to update the count for the current headline, or C-u C-c C-# (org-update-checkbox-count) to update all checkbox counts in the whole buffer.

If you want to see the percentage of completed items, use [%] instead of [/]. I find 7/9 to be easier to understand than 71%, but fractions might work better for other cases.

Okay, you’ve written a lot. How do you find information again?

Searching Your Notes

When you’re writing your notes, you might need to refer to something you’ve written. You may find it helpful to split your screen in two with C-x 3 (split-window-horizontally) or C-x 2 (split-window-vertically). To switch to another window, type C-x o (other-window) or click on the window. To return to just one window, use C-x 1 (delete-other-windows) to focus on just the current window, or C-x 0 (delete-window) to get rid of the current window.

Now that you’ve split your screen, how do you quickly search through your notes? C-s (isearch-forward) and C-r (isearch-backward) are two of the most useful Emacs keyboard shortcuts you’ll ever learn. Use them to not only interactively search your Org file, but also to quickly jump to sections. For example, I often search for headlines by typing * and the first word. Org searches collapsed sections, so you don’t need to open everything before searching.

To search using Org’s outline structure, use C-c / r (org-sparse-tree, regexp), which will show only entries matching a regular expression. For more information about regular expressions, read the Emacs info manual entry on Regexps. Here are a few examples:

To find Search for
All entries containing "cat" cat
All entries that contain "cat" as a word by itself (example: "cat," but not "catch") \<cat\>
All entries that contain 2006, 2007, or 2008 200[678]

Hyperlinks

If you find yourself frequently searching for some sections, you might want to create hyperlinks to them. For example, if you’re using one file for all of your project notes instead of splitting it up into one file per project, then you probably want a list of projects at the beginning of the file so that you can jump to each project quickly.

You can also use hyperlinks to keep track of your current working position. For example, if you’re working on a long document and you want to keep your place, create a link anchor like <<TODO>> at the point where you’re editing, and add a link like [[TODO]] at the beginning of your file.

You can create a hyperlink to a text search by putting the keywords between two pairs of square brackets, like this:

  See [[things that make me happy]] 

You can open the link by moving the point to the link and typing C-c C-o (org-open-at-point). You can also click on the link to open it. Org will then search for text matching the query. If Org doesn’t find an exact match, it tries to match similar text, such as "Things that make me really really happy".

If you find that the link does not go where you want it to go, you can limit the text search. For example, if you want to link to a headline and you know the headline will be unique, you can add an asterisk at the beginning of the link text in order to limit the search to headlines. For example, given the following text:

In this file, I'll write notes on the things that make me happy. (1)
If I ever need a spot of cheering up, I'll know just what to do! 

** Things that make me happy (2) 
*** ...

Example 
Link 1: [[things that make me happy]] 

Link 2: [[*things that make me happy]] 

Link 1 would lead to (1), and Link 2 would lead to (2).

To define a link anchor, put the text in double angled brackets like this:

<<things that make me happy>> 

A link like [[things that make me happy]] would then link to that instead of other occurances of the text.

You can define keywords that will be automatically hyperlinked throughout the file by using radio targets. For example, if you’re writing a jargon-filled document and you frequently need to refer to the definitions, it may help to make a glossary of terms such as "regexp" and "radio target", and then define them in a glossary section at the end of the file, like this:

*** glossary
<<<radio target>>> A word or phrase that is automatically hyperlinked whenever it appears. 
<<<regexp>>> A regular expression. See the Emacs info manual. 

Radio targets are automatically enabled when an Org file is opened in Emacs. If you’ve just added a radio target, enable it by moving the point to the anchor and pressing C-c C-c (org-ctrl-c-ctrl-c). This turns all instances of the text into hyperlinks that point to the radio target.

Publishing Your Notes

You can keep your notes as a plain text file, or you can publish them as HTML or LaTeX. HTML seems to be the easiest way to let non-Emacs users read your notes, as a large text file without pretty colors can be hard to read.

To export a file to any of the formats that Org understands by default, type C-c C-e (org-export). You can then type ‘h’ (org-export-as-html) to export it as HTML for websites. You can also type ‘l’ (org-export-as-latex) to export it to LaTeX, a scientific typesetting language, which can then be published as PDF or PS. Another way to convert it to PDF is to export it as HTML, open it in OpenOffice.org Writer, and use the Export to PDF feature. You can also open HTML documents in other popular word processors to convert them to other supported formats.

By default, Org exports all the content in the current file. To limit it only to the visible content, use C-c C-e v (org-export-visible) followed by either ‘h’ for HTML or ‘l’ for LaTeX.

If you share your notes, you may want to export an HTML version every time you save an Org file. Here is a quick and dirty way to publish all Org files to HTML every time you save them:

(defun wicked/org-publish-files-maybe ()
  "Publish this file."
  (org-export-as-html-batch)
  nil)
(add-hook 'org-mode-hook  ;; (1)
 (lambda () 
  (add-hook (make-local-variable 'after-save-hook) ;; (2)
            'wicked/org-publish-files-maybe)))

(Update: Feb 22 2011: Thanks to Neilen for the fix!)

  • (1) Every time a buffer is set to Org mode…
  • (2) Add a function that publishes the file every time that file is saved.

What if most of your files are private, but you want to publish only a few of them? To control this, let’s add a new special keyword "#+PUBLISH" to the beginning of the files that you want to be automatically published. Replace the previous code in your ~/.emacs with this:

(defun wicked/org-publish-files-maybe ()
  "Publish this file if it contains the #+PUBLISH: keyword"
  (save-excursion
   (save-restriction
    (widen)
    (goto-char (point-min))
    (when (re-search-forward 
           "^#?[ \t]*\\+\\(PUBLISH\\)"
           nil t) 
     (org-export-as-html-batch)   
     nil))))

(add-hook 'org-mode-hook
 (lambda ()
  (add-hook (make-local-variable 'after-save-hook)
            'wicked/org-publish-files-maybe)))

and add #+PUBLISH on a line by itself to your ~/notes.org file, like this:

 #+PUBLISH
 * Things that make me happy

When you save any Org file that contains the keyword, the corresponding HTML page will also be created. You can then use a program like rsync or scp to copy the file to a webserver, or you can copy it to a shared directory.

Integrating Remember with Org

You can use Remember to collect notes that you will later integrate into your outline. Add the following code to your ~/.emacs to set it up:

(global-set-key (kbd "C-c r") 'remember)    ;; (1)
(add-hook 'remember-mode-hook 'org-remember-apply-template) ;; (2)
(setq org-remember-templates  
      '((?n "* %U %?\n\n  %i\n  %a" "~/notes.org")))  ;; (3)
(setq remember-annotation-functions '(org-remember-annotation)) ;; (4)
(setq remember-handler-functions '(org-remember-handler)) ;; (5)
  • 1: Handy keyboard shortcut for (r)emember
  • 2: Creates a template for (n)otes
  • 3: Create a note template which saves the note to ~/notes.org, or whichever Org file you want to use
  • 4: Creates org-compatible context links
  • 5: Saves remembered notes to an Org file

With this code, you can type C-c r n (remember, Notes template) to pop up a buffer (usually containing a link to whatever you were looking at), write your note, and type C-c C-c (remember-buffer) to save the note and close the buffer.

You can use this to store snippets in your notes file, or to quickly capture an idea that comes up when you’re doing something else.

Now you know how to sketch an outline, reorganize it, fill it in, brainstorm, stay motivated, and publish your notes. I look forward to reading what you have to share!

Chapter 7: Managing Your Notes in Emacs – done!

By golly, it’s starting to look like a book.

I just finished putting together my third chapter, which is really chapter 7 in the book: managing your notes and Emacs. This chapter is about taking notes in Emacs, focusing on Remember, Org, Planner, and blogs. At 38 pages, it’s a little over my planned 35 pages, and I haven’t even covered all the things that I wanted to like random information management with Howm, blogging to Blosxom, and customizing Planner templates. Maybe after some really fierce copy-editing, I’ll have some space.

I sent a copy off to my editor, and I just finished uploading a PDF and OpenOffice.org document that you can download and read. There’s also an HTML version, but the formatting is a little wonky. I hope you find this useful! I didn’t blog as much of this as I did last time, so I missed out on all the wonderful feedback people could’ve given me. I’ll do that next chapter.

I formatted most of the chapter this afternoon, hanging out with Leigh Honeywell, Seth Hardy, and a few other geeks at the Linux Caffe. Leigh’s working on a book proposal, and we’re thinking of organizing a writing group for technical authors. We’ll start by meeting this Thursday at Leigh’s apartment. iI enjoyed chatting with them as I worked on my book, drifting in and out of conversations. I think it would be a good idea to work somewhere quieter, with plenty of table room for assorted gadgets, but this was a good start.

Next chapter: contact management in Emacs. I’ve got a lot of fun hacks that I want to share here, so coming up with material shouldn’t be hard. I’ll keep you posted!

(UPDATE: Fixed links. Thanks to Leschinsky Oleg for pointing that out!)

Taking quick notes for books

I love my book notes system. I almost always ask fellow bookworms how they keep track of what they’ve learned from the books they’ve read, and their suggestions have helped me put together a pretty darn good system. Here’s how I work:

Capture: I usually read books in front of my computer so that I can use Dragon NaturallySpeaking to take notes while I read. I speak the page number and the quote I want to remember. Using speech recognition to write book notes means that I don’t have to take my hands off the book, and I don’t have to perch it precariously on my lap as I try to type in quotes. Speech recognition is reasonably accurate, and I love breezing through a passage at some 300 words a minute. This is awesome. This is so much better than my old way of doing things. I suspect this also does good things for my ability to recall important points. When I finish a page, I correct the text that’s already there.

If I’m not at my computer, I record notes into a portable voice recorder. If I’m feeling lucky, I get DNS to auto-transcribe the recordings. This doesn’t usually work. Background noise messes up the recognition. But it’s usually good enough to let me find the pages again. Or–shhh–sometimes I dogear pages. ;)

Organize: I copy the book notes into a plain text file that uses the Org outline mode. I organize my booknotes with the titles as second-level headings, and I sometimes tag the books with keywords.

Store: I copy my book notes onto my Nintendo DS, where I can use
the ReadMore homebrew application to quickly review my book notes on
the subway.

Review: Every so often, I whiz through the books in my book notes system so that I can keep the key points fresh in my mind. This review is also a good opportunity to pass a book’s idea on to someone else.

What would make this even better? A Nintendo or Palm text editor that understood Org files would be just amazing.  Integration with LibraryThing would be nice, too, so that people could easily find out which books to discuss with me. Even without those pieces, though, my system works really really well for me.

What’s your system?

Powered by ScribeFire.