Because monkeys are crazy productive!
NOTE: This document is being constantly updated and heavily reorganized
NOTE: This specification is partly written in manual style so we don't have to write that separately later.
NOTE: The latest version of the template (SVG) used for creating the mockups below can be found here.
Braindump: some really unorganized stuff (don't read this)
The reason for starting this project is first and foremost that I simply haven't yet come across a time management application which fully integrates all key aspects of time management (specifically task management, time tracking, reporting and monitoring).
So far I've encountered applications that implement the task management side of things very well (most specifically Things and OmniFocus) and then there are those that implement time tracking properly (GTimeLog and Hamster). In between there are also a lot of applications, both open source and non-free (proprietary) that implement a couple of very interesting features we could reuse.
Instead of getting straight into it and adapting an existing solution and metaphorically trying to punch a square peg through a round hole I thought it would be a better idea to start with writing a proper specification for what I somewhat tongue-in-cheek refer to as "The Ideal Time Management Application". This is that specification.
A vision is essential to guarantee the success of a project. From a common vision flows the functionality of an application. Here is our vision:
- First and foremost the result must be free/open software.
- This is a community effort, we all work together.
- The goal should always be to eliminate all manual effort on the part of the user
- Usability is key, if it's not easy to use, it doesn't work.
- Re-usability is important, do not reinvent the wheel and give back to the community.
- The code should be elegant (beautiful, flexible, generic, maintainable, robust etc.)
- The application should be completely usable with just the keyboard.
- The number of dialogs should be kept at a minimum.
- Every aspect should be configurable according to the wishes of the user.
- Wherever possible available open standards should be followed.
- It should be relatively easy to edit the underlying data manually without depending on the GUI (e.g. to correct things).
And specifically in relation to time management:
- All time management features (tracking, task management, reporting, monitoring etc.) should be integrated (i.e. a consistent whole) but the application itself should remain modular and not feel monolothic and unwieldy.
The inspiration for this specification came from open source projects such as Hamster (partly vision and a lot of other ideas), GTimeLog (the time mode), Firefox (the bookmarks view), Thunderbird (the search field), Compiz Config (the sidebar), Zeitgeist, Glista and Hotwire (the entry field) and on the non-free side primarily OmniFocus (core concepts), Things (overall layout and look and feel of management mode). Most of the icons are from the Tango icon set and some are from the OpenVista application.
Monkey offers two global modes, planned and chaotic. The way you want to track time determines what mode to use.
If you're new to time tracking or aren't very organized it's a good idea to start off with Monkey's chaotic mode. This is a simplified mode to time tracking which hides all management functionality, requires no up-front planning and allows you to simply track time against pre-defined activities. It results in a less detailed time log, but it's quite a bit easier to track time. The mobile application we've developed also works very well for this mode.
Once you're ready for a more organized approach you'll want to try planning mode.
In planned global mode all management functionality will become available. As this mode follows David Allen's action management method Getting Things Done, you'll want to read up on GTD before you attempt using this mode. The Wikipedia article offers a good start but you'll probably want to buy David Allen's book Getting Things Done: The Art of Stress-Free Productivity.
Another good introduction to GTD is the OmniFocus Basics Video (23MB MOV) in which Ethan Schoonover from the OmniGroup explains the concepts behind GTD and the way they implemented it in OmniFocus (an application we draw inspiration from).
No matter what mode you are using you'll always want to specifically log breaks, interruptions and procrastination separate from your activities. The user interface makes this quite easy. Our application based time tracking functionality also helps out a lot.
The taxonomy system
Before taking a look at the different modes it's important to tell you something about the taxonomy system. To organize everything we've implemented a very generic and powerful classification system based on Drupal's Taxonomy module. Basically a vocabulary is a container for terms, or "tags", which you can then apply to projects, actions and facts or "log entries" or even just use them by themselves. Terms themselves should be relatively short (aim for a maximum of two words).
Here are a few examples of terms organized in vocabularies:
- Categories: Hacking, Work, Day to day, Procrastination, Interuptions
- Activities: Brainstorming, Research, Requirements, Mockups, Architecture, Programming, Bugs, Testing, Meeting, Review, Sysadmin, Writing.
Monkey implements the following modes:
Manage mode is our implementation of GTD where you organize your actions.
Time mode is the mode you actually use to track time.
Edit mode is where you view the facts or "entries" that have been logged and if needed adjust the recorded time spent.
Explore mode is where you go to get a general feeling on how are you doing.
Report mode is the nuts and bolts of filtering by date, activity, category, picking columns, and finally exporting to a format of your liking (HTML, OpenDocument, PDF etc.).
Or using treeviews (think Firefox's bookmarks organizer):
NOTE: the user interface for this view is guaranteed to change
The time tracking functionality builds on top of the task management and taxonomy concepts discussed in the previous section. It is these concepts combined with several time tracking features that make time tracking in Monkey not only enjoyable but also lead to a very accurate record of how time is spent.
We've implemented a widget called the Main Entry Field that one uses to log so called facts or "entries" if you prefer. Basically all you have to do to track time is type some text in the entry field, hit enter and you're done, you've just logged some time. For more information on the main entry field see the Advanced Features section.
Behind the scenes here's how it works, once you submit anything in the main entry field the application will try to match the text typed against projects, actions and terms. If the application manages to match the current text against any of these it will log a fact associated with that particular project, action or term. If not, it will simply create something called an activity and put it in a special list called Unsorted.
- Give an actual real-life example
Might want to discuss activity earlier on
Advanced time tracking
There are a couple of interesting things you may want to become familiar with:
- When you log a fact against a project or an action the application will also log time against the associated terms. So looking at the example below if you logged time on the project "Project Monkey" time will also be logged for the term "Hacking". However, if you log time against the action "Design entire user interface using mockups" time will be logged for the term "Mockups" and indirectly through a child-parent relation with the project on the term "Hacking".
Describe the advanced fact entry syntax
Hamster has a very cool time slider you can use to easily adjust the time you spent on an activity. This slider is ideally suited for edit activities but also works quite well for detailed reporting.
When you hover over an activity you get a tooltip (Pidgin also uses this for when hovering over buddies):
However, what if you could associate a version control repository with a project? You could then display some more helpful messages from the log history during that specific period (filtered on your username). The extended tooltip below progressively discloses the log history.
First is statistical average hours worked per day, then comes the same thing only in month view (might exclude days that are weakly populated, like Sundays to avoid holes). Then there is that graph which could show what type of bird are you – early or late one. It would be possible to drill data down by year and category, but no more.
NOTE: this view hasn't had much attention just and the design of the interface is guaranteed to change
Among other things the taxonomy system discussed earlier allows the creation of very generic widgets for use with reporting, for an example take a look at the mockup of a possible reporting view below.
Note how this is basically a representation of 4 individual vocabularies and their terms. This is not much more than a generic graph widget which displays data from a dataset generated from a SQL query.
Main entry field
The main entry field is the fastest way to use the application to add projects, actions, activities and track time. The main entry field is modal and supports the following modes:
Project entry mode (<Ctrl><Shift>W or :p)
Action entry mode (<Ctrl><Shift>S or :a)
Activity entry mode (<Ctrl><Shift>A or :y)
Time tracking mode (<Ctrl><Shift><Space> or :t)
Managing trigger rules
You can define trigger rules on a global or per project basis. When you enter a fact, Monkey will go through all related rules and execute those that match. Trigger rules allow you to automatically manipulate facts and safe you from having to manually type in repetitive information.
The rule below would allow you to always associate the term Python with the fact when you use the term Programming. This is quite handy because it's more intuitive to type the term Programming (which is an activity) but still allows you to properly track your experience working with particular languages.
1 if "Programming" in fact.terms: fact.terms.add("Python")
GNOME Do plugin
- Single instance application
- Support icons and emblems for visual organization
- For the first prototype we will not support the ability to form hierarchies of terms
- Support for multiple entry syntaxes
- Allow user to define custom syntax
- Support application based tracking using window matching (and/or DBus services)
Export to OpenDocument (Spreadsheet), including graphs
Architecturally significant decisions
- For the first prototype we've decided to stick to using a flat organization scheme, though we're still considering supporting the ability to form hierarchies of terms. There are however some things that need to be worked out for this to be feasible and we're not sure if it's even required. The major advantage of hierarchies seem to be that it they have better relational semantics, however there may very well be better ways to depict relations between terms.
- SQLAlchemy will be used as the object-relational mapper
Generated using yUML, source:
[Action] [Project] [List] [Fact|start_time;end_time;interuption_time] [Activity] [Vocabulary] [Term]
Accerciser (an interactive Python accessibility explorer for the GNOME desktop)