H3RALD - Tag 'productivity' (RSS Feed)

Getting things done... in Wonderland!

h3rald@h3rald.com — Sat, 30 Jul 2011 16:07:53 -0600

I don’t remember the exact day when I started using a todo list in a serious way. It definitely happened at work, but I can’t remember when exactly. The point is that, once I started working (and getting paid for what I love doing – writing), I slowly turned into a real productivity freak.

I write everything down. My colleagues know that if I say that I’ll do something right now but I don’t do it within five minutes, they have to assume that I forgot about it altogether and they’d better send me an email.

I am not a paper person. Never been one. When I got a job which consisted in working on the computer for eight hours a day, I started looking for todo list programs. That turned into an endless quest: I tried X for a few weeks, then I discovered that Y was better, used it for months, then moved onto Z, and so on.

What's wrong with 90% of digital todo lists

Over the past five years, I must have tried dozens of different digital todo lists, and every single one of them had something wrong with it. Here are the most common flaws I encountered in many applications:

Too many fields – I don’t want to specify (or see, either) a due date, a start date, a completion date, priority, effort, risk, tags, categories, sections, flags, stars, projects, reminder, pre-reminder, recurrency, location, contexts, and finally the actual task. I just want to write down what I have to do. Maybe I want to flag it as important. Sometimes I may need to set a deadline with a reminder, but that starts getting complex already.
Too few fields – On the other hand, just a title and a checkbox won’t do. I want some form of categorization and (optional) deadlines.
Not cross-platform – I use Windows at work, Linux at home, my wife has a Mac. We both have iPhones, but someday I may get an Android device, too. There aren’t many todo lists out there that support more than two operating systems, nevermind mobile devices or web access!
Too fiddly – See the first complaint, above. With too many fields almost always comes a complex interface. I don’t want to wait 17 clicks to save my task. I want to type in what I want to do, and press Enter. Is it too much to ask for?
Made for a particular methodology – GTD is great and David Allen is the God of Productivity, but I don’t want to use @contexts or specify next actions because don’t believe in them, therefore I shouldn’t be forced to do so.

90% of the digital todo list suck. Believe me. 10% – perhaps – don’t. Luckily, I just need one, and guess what: I found it!

Introducing Wunderlist: the quest is over!

Wunderlist, the List of Wonders, you can use it anywhere and at any time. It’s so awesome that… I should stop the ass-kissing right now, and get to the facts.

I discovered Wunderlist when my endless quest led me to the App Store. I think I must have installed nearly all the damn todo list apps, even the crappy ones. I didn’t fall in love with Wunderlist at first tap: it took a few install-uninstall cycles, but in the end I settled for it. Here’s why:

Free – Not that it matters that much, I would happily pay a few bucks for a good app. And yes, I did pay for a few todo lists that I dumped afterwards. Bummer.
Cross-platform – iPhone, iPad, Android, Windows, OS X. And Linux? Not really, but who cares: the web app is fine and it probably plays well Haiku as well.
Simple and Efficient – Two clicks to add a task to any list. No compulsory extra-fields, optional deadlines, unlimited lists. Got something important to do? Tap the star on the left of the task to move it to the top of your list and bookmark it.
Amazing email integration – Create tasks via email, share tasks with others via email, get reminders via push… or email. They even email you if you have overdue tasks. Like… everyday! I was so happy when they implemented this feature that I nearly cried when I got the first few emails.
Everything is sync’ed – On your iPhone, iPad, Android device, Windows PC, Mac, web, etc. It’s all there, always, everywhere.

When I finally realized how awesome this app was, I started using it for chores, and as a shopping list. Then I figured it was good enough as a backlog for my open source projects and my web site, and then… Then my wife discovered it.

Why your wife shouldn't use it...

One of the relatively unusual features of Wunderlist is the possibiliy of sharing lists with others. All you have to do is click a button, specify one or more email address, and send invitations out. People will then signup for a free Wunderlist account and they’ll be able to access (as in read/write access) your list.

Because Roxanne, my wife, has an iPhone, she was the most obvious candidate to try out this collaborative feature. First I shared my Shopping list with her: we needed to make a list of things to get for a party, and that was fun. Wunderlist worked perfectly: we went around the supermarket and ticked things off the shared list, which updated in real-time!

All went great until I decided to share the infamous Chores list. You know the one: bills, fees, errands… I used to say things like “it’s on my list, honey, I’ll do it”, or even “Yes… I’ll add it to the Chores, just gimme a minute”. Little did I know that my beloved liked Wunderlist so much that she started using it frequenly, constantly updating the damn chores list with things like “Take the rubbish out” or “Collect the package from the post office”.

I realized she became a true Wunderlist ninja when I found a task called “Flowers for Roxanne!” – starred and with a deadline set to two months ago!

My five work lists

After months of trial, I decided to use Wunderlist at work as well. With caution, of course: I made sure not to write down any sensitive information in my tasks, because you never know. I started off with just one list, but it got crowded very quickly. I now use five lists for work only:

Work [!] – This is the most active one, I use it for things to do ASAP. Starred tasks are urgent and important, and should be dealt with within the day. At work, that’s my default list.
Work [~] – This is for things that in progress, for tasks I delegated to other people, for keeping track of emails waiting for a reply, etc. I tend to check it at least a couple of times per day (if something is really urgent gets moved to the first list).
Work […] – This is for someday/maybes. Something that is most definitely not urgent, and not too important either. I normally review it once a week, except in the middle of August when I won’t be able to do anything because everyone will be on holiday… It will become my default list for a week or two, then.
Work [CoP] – I also work as the coordinator of a Community of Practice, and I want to keep CoP-related stuff separate, so that I know where to look when I can allocate some CoP time during my day.
Work [@boss] – This is a special list for my boss only. We email each other frequently, but rather then sending her long emails she can’t afford to read, I write down discussion topics in this list, which I’ll then load up at the following status meeting.

The next step? Maybe sharing lists with my boss and collegues, who knows…

The bottom line

Saying that Wunderlist is the perfect todo list for everyone would be pointless: there would always be people who wouldn’t agree with that. Wunderlist is not perfect, but close enough for me: it has most of the feature I need, and – most importantly – very little features I don’t need. In the end, this is what makes an app truly awesome.

I give it four stars out of five. Why not five? Because in this way 6Wunderkinder can make Wunderlist even a better product by surprising its users with something they didn’t know they wanted. That’s what Steve Jobs does at every Keynote, isn’t it?

Book Review: Succeeding with Agile

h3rald@h3rald.com — Sun, 25 Apr 2010 06:16:28 -0600

“This is not a book for those who are completely new to Scrum or agile. There are other books, classes, and even websites for that. If you are completely new to Scrum, start with one of those.”

— Mike Cohn, Succeeding with Agile

Great. That’s just great. Good job I started with the Introduction first, otherwise the first chapters of this book would have been way too overwhelming!

Succeeding with Agile is a book that doesn’t teach you about Scrum or agile methodologies, it won’t give you a definition of ScrumMaster, sprint, or backlog… instead, it takes all that for granted and teaches how to pragmatically adopt — or better, ADAPT to — Scrum, in the context of yourself, your team, and even your entire organization.

“[…] this book draws on my experience with Scrum over the past 15 years, but especialle the last 4. For the last 4 years, every evening after I spent the day with one of my clients, I would go back to my hotel room and make notes about problems they were facing, the question they asked, and the advice I gave.”

Indeed, this book is a gold mine of information, anecdotes, tips and tricks about everything you could possibly want to know about making Scrum work, at any level. If you have some knowledge about agile development you definitely have some questions: will it work? … is it really more productive? … how can I make my boss understant this?. This book has all the answers you need. Most definitely, it also answer questions you didn’t think of.

If you don’t know what all this is about, then you’d better do your homework first:

Overview

The book is organized into five parts of different length, ranging from 20 to over 100 pages. If you read the book from the start till the very end, you’ll notice that the start of each part is like a new milestone in Scrum adoption: first the author makes sure that you are prepared (Part 1), then moves on to deal with individuals and initial resistance (Part 2), then teams (Part 3) and finally the whole organization (Part 4), until you can finally taste the fruits of you labor (Part 5).

In a way, you may well want to carry this book in your briefcase every day you go to work, and read it bit by bit, as you make progress in your quest for Scrum adoption.

Part I: Getting Started

Part I is about making sure you know why becoming gile is important and beneficial to you and your work environment. It will teach you how to promote Scrum, its advantages and challenges, and the different ways to go about it: Start Small or Go All In? Stealth or Public Display? Things like that. Pointless theory? Not really: everything is well documented, with success stories to support one way or the other.

Part II: Individuals

This part was very interesting from a psychological point of view: it deals with individuals and their possible reactions to becoming agile. You’ll meet skeptics, followers, saboteurs and diehards — no hope? Well, of course not: you’ll learn how to deal with each one of them in the best way possible. This part will also introduce you to new roles and responsabilities related to Scrum.

Part III: Teams

Up next, Teams. You’re no longer dealing with single-minded individuals, but with more complex groups. New challenges emerge, mostly related to communication and people interactions. I particularly enjoyed Chapter 13 — The Product Backlog, which provides invaluable insights on this important everyday tool. Chapter 15 — Planning is another interesting read: it teaches you a lot about planning vs. estimating, and coming to compromises to meet deadlines.

Part IV: The Organization

If you made it up to here, then you’re nearly done. You probably know most of the tricks by now, but there’s still a lot to learn. Chapter 17 — Scaling Scrum is definitely worth reading, even just for the analysis between formal and informal communities, while Chapter 19 —Cohexisting with Other Approaches almost feels heretical at times: mixing Scrum with Waterfall? Is that even conceivable? Yes. Sometimes it’s the only way, especially when you have to deal with compliance to standards like ISO9001. Once again, the author has a nice success story on how a company passed an ISO9001 audit by providing documentation in form of photocopied notes and by adding a single failing test to persuade the auditor that the automated test suite was not rigged. Priceless.

Part V: Next Steps

Only two chapters in this part of the book, which mainly deals with (self) assessment and progress analysis. Still worth a read, but you can safely leave it out for when you succeeded with agile.

Technical Analysis

I’m not exaggerating when I say that this is by far the best book I’ve read in the past few years when it comes to the way it is organized. Start by reading the table of contents: if you take each chapter out and make a bulletted list of each section you’ll end up with a handy (and free!) cheat sheet on how to promote and adopt Agile methodologies.

This doesn’t mean the book isn’t a worthwhile read, but rather that it can also be used as a reference when needed.

Formatting and Readability

From a technical writing point of view, this book is spotless. I should keep it on my desk to remind me how technical documentation should be written, except that… it’s not a technical manual of course. But the formatting and the way content is laid out can make the most skilled technical writer very jealous: there’s never a huge blob of boring text, never a series of pointless pictures: Mike Cohn (or his editors) did a terrific job composing this book.

You can start reading it from any point and it still makes sense, diagrams are simple and clear, and yet extremely useful, and so are the reference tables and spreadsheets. They never hurt, they are always in the right place, at the right time. And bold text is aptly used at the start of list items, so that even if you skim through the key concepts will still make it to your brain. Excellent.

Style and Contents

Reading this book is like listening to a seminar hold by some charismatic icon like David Allen or JoAnn Hackos: you never get bored, and you constantly learn something. Mike’s informal and conversational style is one of the main reasons why you should read this book instead of others on the subject: he is a great communicator, and he knows how to make his point across.

As an added value, Mike also uses two types of boxes throughout the book:

Things to try now — Whenever a new strategy or practice is introduced, you’ll find one of these boxes containing a bulleted list. “Commit to running the next two or three sprints without any overtime”, “Do you understand what motivates every other person on your team? If not, find out. How? Ask them.”, … these are just examples of some of the author’s reccommendations to put you in the right track.
Objection — Either actual quotes from customers and employees, or possible statements which may come out throughout the process of adopting Scrum. Things like “If the product includes less than what we’ve planned, no one will buy it”, or “My team won’t self organize; team members are too passive and look to me to lead”, … of course, what makes these objection boxes valuable is not the statement themselves, but the tips on how what to do about them. There’s not a single one left unanswered: you really feel you’re covered in any situation.

Final Thoughts

I really enjoyed this book. It took me ages to read it, not only because it’s quite long (450 pages), but also because it’s very dense of information. Another author could have made it three times longer, but I was glad Mike didn’t. I’m pretty certain I’ll keep it near me and read bits from it when I need to: it’s pretty much the Bible of Scrum adoption.

What’s wrong with it then? Not much. Perhaps the only thing I really missed was an introductory 50-page-chapter on Scrum and agile. I know this is not meant to be a book for beginners, but some basic glossary or Scrum cheat sheet would have made it accessible to an even wider audience, at virtually no cost for the author or the readers, who could have just skipped that part.

Anyhow, I give it a 9 out of 10.

Announcement: RedBook v0.5.0 released

h3rald@h3rald.com — Sun, 16 Dec 2007 00:07:00 -0700

This new beta release of RedBook introduces quite a few changes when it comes to configuration and setup. Here’s some highlights…h3. Regexp changes

It is now necessary to enter “proper” regular expressions for :select. Proper means between slashes, like the following:

/Work Day/
/mail/i

I changed this in order to support case-insensitive searches using the i switch. This makes queries much more powerful.

Variables

A new, interesting feature I decided to introduce in this release is variables. For now you define them inside your rbconfig.yml file, like this:

1:var_monday_morning: "monday at 8 am"
2
3:var_friday_evening: "friday at 8 pm"
4
5:var_week_report: ":select :duration :from :%monday_morning :to :%friday_evening"

In this way, every time you type in :%week_report in RedBook, it will expand to: :select :duration :from monday at 8 am :to friday at 8 pm. By the way, completion is supported, so you’ll only have to type in something like :%we and hit .

It is possible to define variables as :var_<something> in the rbconfig.yml file and then used them inside RedBook as :%<something>.

New Operations

Five new operations have been added:

:blank

This will blank your current log after asking you if you really want to do so.

:restore

This operation will overwrite your current log with the last saved backup. Like with the :blank operation, you’re asked if you really want to proceed or not.

:archive

By typing :archive, the current log file will be archived to your :archives_folder: directory specified in the rbconfig.yml file (similarly, it is now possible to specify a :backups_folder: for your logs’ backup files).

:dataset

A simple operation to display the messages inthe current dataset.

:dump

This operation will dump the output of the last :select operation to a text file. Useful for saving the average, total time and duration of a set of activities.

Portable edition

Some Windows users will definitely love this. I finally found an easy way to run RedBook confined within the current directory, by using a simple start.bat batch file to set the INPUTRC and HOME variables temporarily to the path to the .inputrc file and the directory of RedBook executable. This makes RedBook 100% portable and suitable to be used on USB sticks &similar.

Get RedBook Portable

New Development Page

I decided to move the primary RedBook repository from Assembla to Google Code. Why? Well, nothing wrong with Assembla per se, I still think it’s an excellent free service to host your public and private projects, but Google Code is faster and offers only the features I need:

Public SVN repository access
Simple-to-use issue tracker
Very nicely developed downloads section, with download counts, and “normal” filenames.

So here’s the new RedBook Development Home:

http://code.google.com/p/redbook/

Additionally I also setup a RedBook Support Google Group, so if you have any question concerning the program, you know where to go!

Announcement: RedBook v0.4.0 released

h3rald@h3rald.com — Wed, 28 Nov 2007 00:34:00 -0700

I’m pleased to announce a new release of the RedBook daily logging and time tracking script. This release introduces two new operations, four stats-related directives and a brand new Windows Installer able to setup RedBook in a blink, with (almost) no configuration at all.

Let’s have a closer look…h2. New Operations

Suppose that you just logged a message and you noticed one of these two things happened:

You didn’t really wanted to log it
You made a silly typo in the message or in the tags

What can you do about it? Up to RedBook 0.3, the only solution was to open the YAML file and correct the mistake manually. From now on there’s also another simpler way to operate in such situations: using the :update and :delete operations!

:update

This operation can be used to update the message and or the tags of a previously-logged activity. The usage is simple: load a dataset first, and then execute an :update command like:

:update 4 :message My updated message :with new_tag1 new_tag2

This will update the 4th message of the dataset modifying its message and tags. Of course you can update either of the two things or both; the timestamp of the activity will not be changed.

:delete

The delete operation can be used to completely delete a message from the log. Just load a dataset using a :select operation and then execute a :delete command, e.g.:

:delete 1 (will delete the first activity)
:delete 4 2 7 9 (will delete activity #2, #4, #7 and #9)
:delete (will delete the entire dataset)

A confirmation message will appear before deleting the message(s).

IMPORTANT
Due to the architecture of the application, whenever an :update or :delete occurs the log file will be reloaded in memory and completely overwritten. This doesn’t cause problems, although for big log files (10,000+ activities) this may take a few seconds.

Statistics

Another important new feature introduced by this release is time tracking. It was actually already there, kind of: the :calc operation was already able to calculate the time elapsed between two activities… however, this is not really practical.

Since last release, it is possible to log the completion of an activity using the :finish command. This will basically re-log the same activity prepending [COMPLETED] to its message.
If you started using the :finish command to complete your activities, RedBook can now calculate the following stats for you:

Count the number of messages in a dataset
Calculate the average time spent for the completed activities in a dataset
Calculate the total time spent for the completed activities in a dataset
Calculate the duration of each completed activity in a dataset

Each of these calculations is performed by adding special directive to a :select command, as explained in the following sections.

:count

This directive can be added to a :select command to return just the number of message of the loaded dataset.
In other words, executing the following:

:select :count :with mail !work

…will return the number of activities tagged with mail but not with personal, without listing all the activities.

:avg

The :avg directive can be used to calculate the average time spent on activities matching certain criteria, for example:

:select Status Meeting :avg :with meeting

…will return the average time spent on activities whose messages matches /Status Meeting/ and are tagged with meeting.

:total

Similarly, :total can be used to return the total time spent on activities matching certain criteria, e.g.:

:select :total :with mail work

…will return the total time spent on activities tagged with mail and work.

:duration

Lastly, :duration will print each completed task along with its duration. The syntax is similar to the others:

:select :duration :with break

This will print each completed activity tagged with break along with its duration.

:nodiff and _concurrent

The logic behind the above-mentioned directives may seem trivial to implement, but it is not. The fun part was telling RedBook to subtract the duration of each sub-activity contained in another activity… a feature I considered necessary for time tracking purpose. However, if you start your work day with a Working Day activity and you complete that activity using the :finish command, when calculating the duration of the working day RedBook will subtract the duration of all the completed sub-activities from the duration of Working Day. This is not OK, so I added the directive :nodiff which can be used to prevent RedBook from calculating the difference between the parent activity’s duration and the duration of each of its child activity.

What if you’re doing two things at once? use the special _concurrent tag, and that activity will be considered symultaneous to its parent activity for time tracking purposes.

Activity Status Filters

RedBook is now fully aware of the “status” of each activity, so it is possible to display only activities in a certain status using the following directives:

:plain

Executing :select :plain :from today will return all the activities logged today, omitting their completions (if any), i.e. any activity beginning with [COMPLETED].

:pending

Executing :select :pending :from today will return all the activities logged today which have not been completed yet. Again, this was not too trivial to implement, but it seems to work (it also smart enough to detect if the same activity has been relogged etc. etc.).

WARNING:
Using this directive with a large dataset may cause RedBook to take some time before delivering the result, due to the amount of iterations to perform. Use with care.

:completed

Executing :select :completed :from today will return all the activities logged today which have been completed.

Windows Installer

I decided to spend some time (half an hour) and create a proper setup file for Windows using InnoSetup. The setup will take care of almost everything for you, so you have no excuse not to try RedBook because it’s not user-friendly to install!

Check out the manual for more details.

RubyForge Project

Finally, I registered a new RubyForge Project for RedBook, which include a public SVN repository updated every week (Assembla doesn’t allow anonymous checkouts, unfortunately).
This project will also host the official RedBook Gem, scheduled for the 1.0 release.

DOWNLOAD | MANUAL

Announcement: RedBook v0.3.0 released

h3rald@h3rald.com — Wed, 24 Oct 2007 23:18:00 -0600

It’s time for a new beta release of RedBook. This was actually going to be a fairly modest release in terms of features, but I actually ended up implementing a lot more than expected, even things which were planned for the first production release 1.0. So, let’s see what’s new

New operation names (which break compatibility with previous versions)

I had a look at the names I choose for the operations and I noticed that they were either not intuitive enough or too verbose. So I decided to change a fair few of them (thus breaking compatibility with previous versions, but after all that’s what beta releases are for, right?):

OLD	NEW
:complete	:finish
:load	:select
:load_config	:config
:load_log	:refresh
:timecalc	:calc
:stop	:quit

New Manual/Home Page

A while ago I discovered TiddlyWiki, but as a matter of fact I never used it for anything practical. From last week though, I started using it a work for taking notes and create short memos, and then I thought of using it to replace RedBook’s standard README file (which was made in a hurry and was kinda cryptical). Now a brand new “manual.html” ships with RedBook — 308 KB (30 of actual docs and 278 of Javascript/HTML/CSS magic) with everything you need to know about it. Additionally, an online version is available at the following address:

redbook.h3rald.com

Removed Win32::Console Library

OK this is not good news for people (like me) who use RedBook on Windows, but I promise you’ll forgive me when you read about the other new features below. I discovered by chance that the Win32::Console library (which was used to get colors working on Windows) seems not to handle international characters properly and also seems to be conflicting in some way with the Readline library I decided to include (see below). I don’t know whether this is a problem of the actual library or just of the gem used to pack it.

rbconfig.yml

The config.yml file has been renamed to rbconfig.yml. Additionally, if you place a file with this name in your $HOME directory it will override the one in your RedBook folder (This was done in preparation for the RedBook RubyGem).

New operations

The following new operations are available:

:relog — Re-logs a previously-logged message (keeping the same tags and updating the timestamp)
:clear — Clears the screen.
:ruby — Evaluates arbitrary Ruby code outputting the result (use with care…)

Auto-completion

Some Mac users originally complained that the backspace key wasn’t working in RedBook (and it didn’t in Linux either). Fortunately the solution to this was easy enough: include the GNU Readline library.
Readline is now being used in RedBook to:

Provide basic (Emacs-style) bindings
Auto-completion for keywords and tags
Allow the user to automatically customize key bindings via an .inputrc file placed in their $HOME directory (on Windows you’ll have to define a HOME environment variable pointing to a directory of your choice). An example .inputrc file is distributed with RedBook with some specific key bindings.

Support for international characters

Finally, I decided to implement another feature which was originally planned for the 1.0 release: international characters support. This is possible using the Iconv Ruby extension (requires GNU libiconv) which can convert strings between different character sets. The character sets needs to be configured via the rbconfig.yml file.

For more information, check out the ChangeLog

Download RedBook

Announcement: RedBook v0.2.0 released

h3rald@h3rald.com — Sun, 07 Oct 2007 21:05:00 -0600

“Release Early, Release Often”

— Eric S. Raymond, The Cathedral and the Bazaar

In other words, time for another (early) release of RedBook. There are quite a few new features which are worth examining, in particular:

Regexp search for messages

This was actually already available before, just if you inputted a search string which was not a regexp, you’d get an unhandled exception (more or less). This exception is now handled propertly so you get a pretty message instead, if an error occurs when parsing the search string.

Log Backup

A new :backup keyword is available to quickly backup your log file. Here’s what it does:

Loads all messages silently
Writes them to a file in the same directory as the original log file named <log-alias>.bkp.yml.

Handy, especially if there was a similar keyword to restore the last backup, which is planned for later on.

Support for multiple log files

This is perhaps the most important feature introduced by this release. It is now possible to configure more than one log file by adding any number of :data_<alias>: settings inside your config.yml file, where alias is the name of your log file. So, for example, if your config.yml file contains the following:

:data_test: “testlog.yml”

You can load the “test” log by typing

:use test

(:use is a shorthand for :load_log). Similarly, another new keyword :dest has been introduced to be able to log a message to a different log file without loading it into memory, like this:

:log This message will be saved to testlog.yml :dest test

Finally, a :refresh keyword has been introduced as an alias to reloading the current log.

(Almost) automatic log of completed activities

Right when I was coding the :timecalc operation, I thought it would be nice to be able to log the start and end of a task without having to type it twice. Now this is possible using the :complete keyword:

:log Testing feature X in product Y

:complete

:complete will re-log the last message prepended with [COMPLETED]:

4 Mon Oct 08 2007 – 10:47:45 AM Testing feature X in product Y 5 Mon Oct 08 2007 – 10:54:31 AM [COMPLETED] Testing feature X in product Y

What if I start another task before completing the first one? No problem, it is sufficient to load the last activities using a :load command and then issuing :complete <number> where <number> is the index of the loaded activity.
This nifty little feature will become more and more important when (starting from release 0.4) I’ll implement more time tracking functions, and it will be possible to track completed tasks in a specific timeframe and/or marked with a specific tag.

Easy integration with launchers like Launchy and QuickSilver

To conclude, as someone pointed out that it would be cool to use RedBook from launchers like Launchy or Quicksilver, I made another standalone script (redbooklet.rb or redbooklet.exe) which is just able to parse a log command and write a message to the specified log file.
To use it with Launchy, for example, all you have to do is the following:

Create a shortcut to redbooklet.exe (or to a way to execute the corresponding ruby script) named “log”.
Copy the “log” shortcut anywhere in your start menu
Bring up launchy (ALT+SPACE) and type in “log”
Hit tab
Type in your log message, optionally with the any :tags or :dest keywords.
The message will be logged to your default log file or to the log you specified using the :dest keyword. If an error occurs, it will appear in a command line window for 15 seconds before the program is closed.

That’s all folks! As usual, if you have any comment or suggestion feel free to reply to this post or email me. For a list of the planned features and releases, check out the Milestones page.

DOWNLOAD HERE

RedBook - A simple Ruby program for your daily logging needs

h3rald@h3rald.com — Sat, 29 Sep 2007 06:05:00 -0600

Logging your daily activities is important. If you don’t believe me you’d better check at least these three posts on LifeHacker, which feature different scripts and applications:

I had a look at each one of them, and I believe they are quite useful, although I didn’t really find what I was looking for. Why? Well, for example:

I don’t believe a GUI is necessary — you’d better off with just a shortcut key or command to run from Launchy or QuickSilver, that’s much faster.
They just log timestamped messages on a file, there’s no real way to search through them and display them except by using a test editor
They are Windows only — not that it matters for me, but others may not be happy about it.

That’s why I thought I’d roll out my own: meet RedBook.
Let me say it’s nothing fancy: I’m not a full-time programmer but I do like playing with Ruby during my lunch breaks at work, so that’s why RedBook is just a humble, tiny Ruby script. This automatically makes it cross-platform: you can install Ruby very easily on Linux & alikes, Mac OS X and Windows. Furthermore, if you are on Windows and for some weird reason you don’t want to install Ruby, you can just try out the packed EXE file (made with RubyScript2Exe) — it’s about 2MB, but you won’t need anything else.

How It Works

The program uses two YAML files, one for configuration, which must reside in the same directory as redbook.rb (or redboo.exe) and one for the log itself, which you can place anywhere, provided that you edit the configuration file accordingly. For information on how to install RedBook and how to configure it, you can check the manual.html (powered by TiddlyWiki) file provided with the program or browse it online.

When started, RedBook will load both the configuration file (config.yml) and the whole log file into memory — it’s not a big deal, considering that they are only text files after all. I did a test with a log of quite a few MBs, and it was fine.

You can then start input commands right away, following a few sample rules. RedBook has a (very) rudimentary parser which is able to detect keywords, i.e. alphabetic strings prepended with a colon. RedBook commands look like this:

:log This message will be logger :tags tag1 tag2
:select :last 15 :since January
:save /home/h3rald/backup.yml

If everything goes OK, RedBook will reply with some sort of response, an acknowledgement, a list of messages, etc.

Simple.

Here’s basically what the program can do:

Log any message to the main log file. Messages can be tagged with one or more tags and will be automatically timestamped.
Load/display a list of logged messages on the screen. It is possible to filter messages by specifying a time span, a string to search in the message text, or a list of tags.
Dump loaded messages to a TXT, CSV or YAML file (you can even backup your log saving it to another YAML file in this way).
Calculate the time elapsed between two or more tasks. Time will be displayed in years, months, weeks, days, hours, minutes and/or seconds as necessary.

How? Here’s a short tutorial…

A Quick RedBook Tutorial

Let’s assume you are able to run RedBook on your system by now (if you can’t find some of the gems which are required for it, you can download them packed in a ZIP file from here).

Here’s what happens when you start the program:

Good. Let’s start logging something then. Just use the :log keyword, followed by a message, and then you can also add the :tags keyword followed by space-separated tags, like this:

RedBook >> :log My first message :tags test
>> Logged.
RedBook >> :log This is another message
>> Logged.
RedBook >> :log This is another message :tags test another_test
>> Logged.

Try waiting a few seconds between each message. These three messages will be appended to the log file. You could open it in an editor, but it’s normally easier to display them directly inside RedBook, like this:

RedBook >> :select
1 Sat Sep 29 2007 – 09:09:32 PM My first message [test]
2 Sat Sep 29 2007 – 09:10:51 PM This is another message
3 Sat Sep 29 2007 – 09:11:45 PM This is another message [test][another_test]
>> 3 messages loaded.

Easy. What if you have hundreds of messages? Well, the :select operation can take an optional search string, or you can tell RedBook to load only those messages tagged with one or more specific tags, like this:

RedBook >> :select :tags test
1 Sat Sep 29 2007 – 09:09:32 PM My first message [test]
3 Sat Sep 29 2007 – 09:11:45 PM This is another message [test][another_test]
>> 2 messages loaded.

Or you can use the :from and/or :to keywords to specify a certain time frame, like this:

:select :tags test :from ten minutes ago

:select :from last week :to 2 days ago

RedBook includes a very nice “natural language date/time parser”, Chronic which is able to convert sentences like the following into Ruby Time objects:

6 in the morning
friday 1pm
sat 7 in the evening
today
yesterday at 4:00

It’s not perfect (and it’s in pre-alpha as well), but it does the job, for what I can see, and it makes it very easy and fast to specify timeframes.

After executing a :select command, two other operations can be performed on the loaded messages: :calc and :save.

:calc calculates the exact amount of time elapsed between two or more tasks. Do you remember the numbers on the far left of each message? Think them as temporary IDs for the actual messages, and you can use them to select specific tasks when executing the :calc operation:

RedBook >> :calc 1 3
1 Sat Sep 29 2007 – 09:09:32 PM My first message [test]
- 2 minutes and 13 seconds.
3 Sat Sep 29 2007 – 09:11:45 PM This is another message [test][another_test]

Similarly, if no IDs are specified, :calc calculates the time difference between each message and the previous:

RedBook >> :calc
1 Sat Sep 29 2007 – 09:09:32 PM My first message [test]

- 1 minute and 19 seconds.

2 Sat Sep 29 2007 – 09:10:51 PM This is another message

- 54 seconds.

3 Sat Sep 29 2007 – 09:11:45 PM This is another message [test][another_test]

Finally, you can save loaded messages to a TXT, YAML or CSV file, as follows:

RedBook >> :save log.txt
>> Saving…
>> Saved dataset to “log.txt”

h
If you want to backup your log, you can load all messages and then save them to a YAML file. Maybe in this case you want to append the :silent keyword to the :select command, so that messages won’t be displayed on the screen.

Conclusion

RedBook is just a simple program: it suits my needs for now, but of course there’s roo for improvement. If you have some useful suggestions, or you want to contribute in some way, feel free to contact me!

Home Page | Development | Download

Introducing RedBook (and the new Code section)

h3rald@h3rald.com — Fri, 28 Sep 2007 18:12:00 -0600

I’m somehow pleased to announce the opening of a new section on this site. Nothing too big actually, it’s just a page with a few (one for now) brief descriptions of open source programs and scripts I made and I’d like to share with my readers.

Don’t expect fancy stuff: (luckily) I don’t code for a living, I code for pleasure and I code small things. Lately I’ve been trying to write a small Ruby program able to log my daily activities and also display them in a pleasant enough way, so I started using my lunch breaks at work more constructively and I came up with RedBook an interactive command-line program written in Ruby.

Main features:

Log timestamped and tagged messages to a single YAML file
Load and display messages containing a certain string, or certain tags or within a time frame.
Calculate the time elapsed between two or more tasks.
Export loaded messages to YAML, TXT or CSV format.

All done via command line via simple commands:

:log This is a test message :tags test

:load :last 30 :from last week

:timecalc 2 5

:save test.txt

Thanks to the wonderful Chronic library, you can specify your time frames using natural language expressions like “8 in the morning”, “this tuesday”, “last month” and so on…

Here’s a screenshot showing RedBook in action:

RedBook is of course free, open source software licensed under the terms of the BSD license. It can be installed on any machine able to run Ruby and there’s also an EXE version for the lazy windows folks who don’t want to install Ruby, packed with RubyScript2Exe. A more in-depth article explaining how RedBook works ~~will hopefully be completed soon~~ is available :here

Information Mapping

h3rald@h3rald.com — Thu, 01 Jun 2006 22:10:00 -0600

As I thought, my job also represents a great opportunity to learn new things. I don’t mean only new technical stuff, but also a great deal of tips, best practices and methods to efficiently write documentation material in proper English. Some theory about Information Mapping was by far the most interesting topic I learnt about this week.

What is Information Mapping?

Definition¹

The Information Mapping method is a research-based approach to the analysis, organization, and visual presentation of information.

Information Mapping is media independent

The method is both subject matter and media independent; that is, it can be applied to the subject matter of any industry, and it can be presented on paper, on a computer screen, verbally, or in a multimedia presentation.

Key Concepts

Information Mapping is an integrated set of easy-to-learn principles, techniques, and standards. It enables authors to break complex information into its most basic elements and then present those elements optimally for readers. The result is a set of precisely defined information modules that are consistent from author to author and document to document.

Purpose

The method helps writers analyze, organize, and present information with clarity focus and impact. Information That Works. The goal of the analysis component is to determine the

purpose

audience needs, and

information types.

The goal of the organization is to create an overall structure for the information, based on the results of your analysis. Finally, the goal of the presentation component is to format the information to make it clear and accessible to your audience.

¹ Contents were taken from InfoMap.com and were re-formatted and re-organized into an information map.

Key Concepts

Introduction

The Information Mapping method relies on some important principles according to which information should be organized. This method also defines new units of information to replace paragraphs, sections and chapters and tries to divide information into a few main set types, each with its own rules and structures.

Principles

Name Explanation

Chuncking Writers should group information into small, manageable units.

Relevance Writers should make sure that al information in a chunck relates to one main point (function or purpose).

Labeling Writers should provide a label for every unit of information.

Consistency Writers should use similar labels, word, formats for similar subject matters.

Integrated Graphics The use of tables, images, diagrams and lists is encouraged.

Accessible Detail Documents should provide sufficient details where necessary, to make the information more accessible for the readers.

Hierarchy Small, relevant units of information should be organized into a hierarchy.

Information Types

Name Definition

Procedure Set of steps to obtain a specified outcome

Process A series of changes through the time for some purpose

Structure Something which can be defined into multiple parts

Concept Group of physical objects, conditions, relations, …

Principle Statement of what should be done, assumptions

Fact Statement presented with no supporting evidence

Classification The sorting of a group of specimen into classes

Conclusion

Although it may initially seem too schematic, Information Mapping is a valid method to organize and present information to those readers who just need “facts” without any unnecessary distraction. This method it is used with some modifications in many technical manuals and documentation written by many companies.

Name	Explanation
Chuncking	Writers should group information into small, manageable units.
Relevance	Writers should make sure that al information in a chunck relates to one main point (function or purpose).
Labeling	Writers should provide a label for every unit of information.
Consistency	Writers should use similar labels, word, formats for similar subject matters.
Integrated Graphics	The use of tables, images, diagrams and lists is encouraged.
Accessible Detail	Documents should provide sufficient details where necessary, to make the information more accessible for the readers.
Hierarchy	Small, relevant units of information should be organized into a hierarchy.

Name	Definition
Procedure	Set of steps to obtain a specified outcome
Process	A series of changes through the time for some purpose
Structure	Something which can be defined into multiple parts
Concept	Group of physical objects, conditions, relations, …
Principle	Statement of what should be done, assumptions
Fact	Statement presented with no supporting evidence
Classification	The sorting of a group of specimen into classes