A Project for 2017

Happy New Year!

This is the start of Year 3 of this blog. For an overview of the past two years, see my review posts:

• Summer Review (January to July 2015)
• Red-Green-Code: 2015 in Review (the rest of 2015)
• Red-Green-Code: 2016 in Review (all of 2016)

For 2017, I have decided to start a new programming project. It will coexist with my other programming project, Project 462. But while Project 462 is strictly a learning project, this new project will produce code that is designed to be used and maintained. (Though as with most programming projects, there will be learning as a side-effect).

Time Tracking

In April of last year, I wrote a wish list for a time tracker app. The short version: When I’m working, either on job activities or on my own projects, I use a set of tools to track my productivity. My process works fine, but it’s not ideal. Because it involves manual steps, it’s not as efficient as it could be. The manual steps take time away from real work. And I have ideas about potentially useful processes that I don’t implement because they would be too tedious to track manually.

One of the advantages of being a programmer is that you don’t have to be satisfied with existing software. You can write your own! In the case of time tracking tools, plenty of programmers have done that. Why start another one? I can think of several reasons:

• I have tried a lot of time trackers: I have tried many time trackers over the years. Some are too simplistic for serious time tracking. Others are hard to use. The one that I have been using for many years is designed around particular commercial use case, tracking time for billing purposes. It’s still an excellent personal time tracker, but it doesn’t match exactly what I’m using it for.
• Productivity systems are personal: While others can give you ideas about productivity habits, it’s most effective to construct your own customized system. That’s what I’ll be doing with this project. And it may turn out that others find it useful as well.
• Any programming project can be good practice: Though I plan to replace my existing time tracker with one that I build myself, it may turn out to be less useful than I predict. Nevertheless, it will be beneficial as a way to try out programming ideas and patterns. It’s handy to have a real project around to try things out.
• Contrast with competitive programming: It’s common on Quora to contrast competitive programming with real-world programming. I expect that it will be useful to have one project from each category to use as examples when I’m writing about topics like deliberate practice.

Goals

There are a lot of time tracking programs out there, but they weren’t all designed with the same goals in mind. Here’s the primary goal of the one I’m going to build:

• Influence how time is spent: Tracking time can be seen as the first step in changing how you spend time, rather than as an end in itself. That decision will affect the functionality of this tracking tool. For example, there won’t be any need for billing or multi-user functionality.

Other goals include:

• Make it easy to add productivity goals: I can achieve some of the functionality I have in mind for this tool with an existing time tracker, a spreadsheet, and a task tracker. The advantage of that system is that it’s easy to try out new ideas. The disadvantage is that I have to maintain them manually. With a custom-built tool, I’ll be able to implement new ideas, and have the tool maintain them with minimal ongoing effort. But that will only work if the design supports an easy way to add new goals.
• Single-user, multi-device: The tool is intended for one person who wants to influence their work habits. However, that one person may be using multiple devices (e.g., a work and home computer). So it will be important that data be synchronized between devices in some way.
• Targeted at programmers and people doing similar knowledge work: Initially, the tool will be targeted at people who work in front of a traditional computer or laptop, rather than a small mobile device. Although work can be done on a smartphone, this initial target platform will capture most of the intended work scenarios.
• Track both time and focus: Work Accomplished = Time Spent x Intensity. Standard time trackers cover time spent. But once you have a framework in place for tracking time goals, why not track focus (work intensity) goals as well? Unlike time, focus doesn’t have standardized units like hours, minutes, and seconds. But there are some qualitative and quantitative measurements that can be used to track work intensity.

Features

Here’s an initial list of features that will help accomplish the above goals.

Track time by activity

This is basic time tracker functionality. You have a list of activities. When you start or stop working on one, you start or stop a timer. At any time, you can check how much time you have spent on each activity over various time periods.

Here are some other aspects of this feature that I consider mandatory for a useful time tracker:

• Add and remove activities
• Categorize activities: I’m thinking that a tagging system will be the best implementation. Categorization is important for goals to work properly. For example, you might want to define a set of work tasks and a set of personal tasks, and track separate goals for each set.
• Detect inactivity: I don’t use any time tracker without this feature. It’s inevitable that I get interrupted or wander away from the computer without stopping the current task. If the time tracker doesn’t offer the choice to exclude that away time, then it’s impossible to keep the data clean.
• Easily adjust recorded time: This is for the case where you don’t leave your computer, but you switch tasks without notifying the time tracker. All time trackers allow editing recorded time, but I haven’t found one that makes it extremely easy to do so. Given how often I make adjustments to time, it needs to be a lot easier. I have a few ideas on how to accomplish that.

Track time goals

Tracking time goals supports the key purpose of the tool, which is to influence how time is spent. Here’s how I envision it working:

• Set goals for how much time to spend on a task or task category: The tool should be able to track time goals at multiple levels of granularity. For example: spend four focused hours between 10 AM and 6 PM; or spend ten hours on a particular project between Monday and Sunday. The purpose of the first example is to support an “allocate blocks of time” or “plan every minute” goal.
• Implement a “time bank”: Sometimes it’s useful to set a fixed daily goal while allowing some flexibility depending on what comes up each day. I explain the details in The Time Bank Productivity System.
• Lock goals for the current day at a configurable time: There are benefits to setting daily goals in the morning, or the previous evening. The tool could support this by making goals read-only after a particular time (such as midnight).
• Track whether a day is a work day or a non-work day: Different goals make sense for different day types. It’s easy for software to look up whether a day is a weekday or a weekend day, or even a holiday in the current locale. But that doesn’t account for personal schedules (e.g., vacations), so it will be necessary for the user to provide some context about how time for a given day should be interpreted. For example, work goals would not apply on a vacation day, while personal projects might get more time.

Track streaks and achievements

Once we’re tracking time data and goals, the next logical step is streaks and achievements. A streak tracker can be implemented by selecting a goal and recording how many consecutive days it is accomplished. “Consecutive days” could also be defined to mean consecutive work days, or consecutive non-work days.

An achievement is like a special type of goal. It’s a recognition by the program that you have accomplished something. Presumably there would be a screen in the program where you could admire your achievements, see which achievements remain to be achieved, and define new achievements.

Streaks and achievements are just productivity hacks that encourage you to accomplish goals over time.

Track focused work

As explained above, duration is only one component of productivity. It’s hard to calculate the value of a block of work without knowing something about focus quality.

• The most popular measure of focus is the Pomodoro, a 25-minute block of focused work. I have found this simple measurement to be useful, so I plan to include it in the tool.
• The full Pomodoro system defines a system of work time and break time. The tool could facilitate tracking both of these types of time blocks.
• Quality of focus (work intensity) could be measured using a combination of user feedback and data analysis by the program. For the former, we could define a qualitative focus scale — e.g., a 5-point scale where 1 is completely focused, 4 is minimally focused, and 5 would mean that the time is not recorded as focused time. For the latter, the tool could record what programs are running (e.g., email), which web sites are visited, and how often task-switching occurs. Clearly there is room for quite a bit of complexity in the qualitative aspect of this feature.
• If we’re tracking focus, then it makes sense to include focus goals, streaks, and achievements.

Synchronize between multiple devices

For goals to be useful, the tool would need to be able to combine data from every device on which you are doing work that you want to track. There are some implementation details to work out around getting data between devices. (Cloud storage is the standard choice these days). Also, as I explained above, I’m considering a device to be a desktop or laptop computer for now, due to the type of work I want to prioritize.

Reminders

A time tracking tool is only useful if you use it. To make sure you don’t forget, why not have the tool remind you? Here are a few possible reminders:

• Start an activity: If the computer is in use but the timer is not running, should it be?
• Categorize away time: If the computer is not in use but the timer is running, what should the away time be assigned to?
• Set goals for the day: Goals only work if the tool knows about them, and it’s better if they are all set in advance.
• Start planned work: If you planned to work during a block of time (“plan every minute”), show a reminder when that time period is about to start.

Notes

Store free-form notes that can be displayed along with the timing and focus data. For example: main objective for the day.

Dashboard

I have two views in mind for the UI:

• A very small window displaying the current activity and elapsed time. This is what the tool would show most of the time, when you’re working on a task.
• A large dashboard window showing other information like active goals, statistics, tools for editing time blocks, and settings.

Reporting

While the dashboard will show some reporting data, more complex reporting can be accomplished by exporting data to a CSV file, which can then be imported and analyzed in a spreadsheet.

Changing settings

Goals are more useful if they’re not too easy to change. If you do need to change certain types of data, the tool should make you jump through a few hoops to make sure you’re serious. For example, if you commit today to spend two hours on a project tomorrow, you shouldn’t be able to just edit a time value in the dashboard to change the goal to one hour.

Integration

There’s no reason for one tool to do everything. Data from other tools can be combined with time tracking and goals data. Here are some potential integration points that would make this tool more useful as part of an ecosystem.

• Internet activity tracking: You can infer something about focus by looking at what you’re up to on your computer. RescueTime is a popular tool that tracks Internet activity and allows you to categorize it.
• Excel and other spreadsheets: CSV format is the standard solution for importing and exporting spreadsheet data.
• Other time trackers: If the tool makes suggestions based on past activity, it could be useful to import historical data from other time trackers.
• Other types of trackers: Other trackers could provide data that is relevant to time tracking goals. For example, Fitbit tracks sleep and wake times, and a calendar app could provide information about when vacation days are scheduled.

Technology

In discussing the features of this time tracking tool, I haven’t been too specific about what it will be built with, other than to say that it will target desktop and laptop computers. I’ll address that now.

Although this blog runs on LAMP and my other project focuses on Java, I do my work in a Windows environment. So I’m picking a technology stack that works best on that platform. Since it’s 2017 and I’m starting this project from scratch, I’m going to build it as a Universal Windows Platform (UWP) app, using XAML for the UI, SQLite/Entity Framework for storage, and C# for business logic. As a backup plan if I run into technical limitations, I can switch to WPF and preserve most of the code.

Non-Functional Requirements

Here’s a partial list of non-functional requirements for this time tracker:

• Open source: Once I have something minimal working, I plan to start pushing updates to GitHub.
• Well unit-tested: I want to use this project to try out new things, but I also want it to be a reliable and accurate time tracking tool. I’ll be using unit tests to verify that each system component does what it’s supposed to do, even when I’m making experimental changes.
• Modular: I want to be able to add new features incrementally without breaking parts of the system that already work.
• Configurable: The point of building yet another time tracker is to have a system that I can use to easily try out time tracking ideas. For that to be useful, it will have to be easy to set up goals and change how tracking works via configuration.

Next Steps

Expect to see more posts about this project as I work out the design details and publish the code. If all goes well, the tool will also generate ideas about productivity techniques, learning, and deliberate practice applied to real-world coding.

(Image credit: Michail Kirkov + imgflip)