Things 0.9.3 brings dock badges, more compact Next and Today lists, 8 bug fixes, and a new “Cancelled” status for To Do items. While the latter is obviously a new feature, the deeper reason behind it, was to remedy a limitation in previous versions.

Previously, when a project that still contained incomplete items was checked off and eventually got moved to the Logbook, the incomplete items still remained in the Next or Today lists. While this is not entirely wrong, it is probably not what the user wanted. Either the user forgot to check off those items, in which case there should be a warning, or there was a deliberate decision to leave those items incomplete.

Of course, obsolete to-dos can always be deleted. But sometimes it is interesting to keep a record of tasks that were once considered interesting (by a client or co-worker for example), but got axed nonetheless. It is now possible to state that a task got cancelled by using the corresponding new menu command from the “Items” menu.

Also, if a user attempts to check off a project that contains incomplete items, there is warning dialog that lets the user choose whether the remaining items should be marked as completed or as cancelled.

We also introduced an option to show a dock badge. In Preferences you will find a new menu which allows you to select which count will be attached to Things’ dock icon.

Please consult the Release Notes for a full list of bug fixes.

We have all seen how the iPhone enabled applications that weren’t possible before on any mobile device. Wouldn’t it be cool if you could carry all your to-dos in your pocket? Wouldn’t it be cool if you had a powerful responsive task manager wherever you go?

A resounding “Yes” was the answer we gave to ourselves some time ago when we began developing what will become Things touch. Honestly, will any mobile device that you carry around ever be complete without a personal task manager? We didn’t think so either :)

The iPhone and iPod touch are a huge opportunity for developers and an equally huge challenge too.

The opportunity

iPhone and iPod touch constitute a whole new platform with a new distribution model as well - the iTunes app store. These devices are used by many people that have never owned a Mac before and some of them may never will. For a developer there is the potential of reaching a whole new group of customers. Customers that may not know Things already, or are not able to use it because they are on Windows, or may not even bother to use the desktop version at all because Things touch is already more than they bargained for.

Challenges abound

• The iPhone user interface is completely different from what we have become accustomed to from the desktop. Naturally, we had to recreate the code for the Things touch user interface from scratch. No way to reuse a single line from the desktop version.
• Due to the unique limitations of the iPhone OS we couldn’t even port the data model code. Yes you assume correctly, a complete rewrite was necessary too.
• Fraser Speirs has an insightful article on how the market’s ability to establish a fair price for iPhone applications will eventually determine whether there is a sustainable business model for creating them. I bet that we are not the only developer having a hard time determining a price point for our iPhone application. A price point that will enable us to aggressively evolve and support Things touch for a long time to come.

While developing Things touch does draw significant amounts of resources from the desktop version, it is in fact rather beneficial for it too. Recreating Things for the iPhone made simplicity even more predominant. We learned a couple of things from the process that will help us to make the desktop version even better. The same goes for the data model code. Having had the opportunity to incorporate all the lessons we’ve learned from the desktop version resulted in a fresh new code base that will find its way back into Things, providing an even better foundation for its future development.

In the weeks to come, we plan to write more about how Things touch will look like. But if you’d like to get a glimpse of where we are headed, you may want to peek at Chris’ desk :)

On previous systems, syncing to-dos between applications was a complicated process that sometimes even had to be triggered manually. Since we wanted to provide the best experience for our users, and most of them are on Leopard anyway, it was clear that we wanted to use Leopards to-do service instead of the older slow sync. Unfortunately the new and older APIs cannot be used at the same time. Providing backwards compatibility with Tiger is a whole new development effort, which we might attempt later along with .Mac sync.

Getting Started

You turn on iCal sync from Things’ preferences:

In addition to what you might recall from our previous post, we have now included an Options button. It opens a sheet (see below) where you can customize whether tasks show their associated project and tags in other applications.

These options are turned on by default. You can also add tags and projects from iCal or other applications. For example, adding “@Home” to the title of a to-do in iCal instructs Things to add the tag “Home” to it. There is no need to worry that this feature is triggered by accident, since only existing tags are used. You can safely enter email addresses for example. These won’t be recognized as tags and don’t trigger the creation of new tags in Things. The same goes for projects. Only existing projects are recognized and no action is taken if multiple projects with the same title exist in Things. Things is also smart enough to ignore projects that are already logged or in the trash.

We have carefully taken precautions to prevent you from shooting yourself in the foot :). It is not possible to delete to-dos from Things by deleting them in other applications. Since we have no control over applications that integrate with system-wide to-dos, we cannot prevent situations where a large number of to-dos might be accidentally deleted by badly written third party apps.

It is also not possible to delete tags, or projects from other applications. It is just too easy to accidentally type over a title deleting all meta data that might be there. And to-dos removed from their project or missing their tags might be very difficult to find. The iCal sync feature has been designed with the assumption that Things is the primary to-do manager and that other applications, like Mail or iCal, are mostly used to conveniently retrieve stuff or enter new items.

Complete Control

If you want complete control over the syncing process, choose “Custom” from the Sync menu. The dialog transforms into advanced mode allowing you to associate different lists (foci), tags, projects, and areas of responsibility with each calendar.

You do not need to worry whether the list of to-dos you sync with each calendar overlap. If they do, Things will simply sync with the first calendar in the list that matches. Of course, you can reorder the list of calendars in Things.

The criteria you associate with each calendar work both ways when it makes sense. For example, if you specify the “Errand” tag for a certain calendar, then only items having the “Errand” tag are synced with this calendar. If on the other hand you enter a new item in iCal, this item will automatically get the “Errand” tag in Things. The latter, however, only works with a single tag. If you specified multiple tags, there is no way to find out which one you would like to be added in Things. The same is true for projects and areas of responsibility.

Usage Scenarios

Here are some usage scenarios that might not be completely obvious:

• When you create a to-do in Mail using a selection of an email message, the URL for this message is added to the notes section of the corresponding item in Things. Clicking on it will open the associated email message in Mail. Please note that due to a bug in Apple Mail, it will only honor the deletion of to-dos when running. Superfluous to-dos need to be manually removed from Mail.
• You can also use iCal subscriptions. Let’s assume you subscribed to the calendar of your significant other. Just activate this calendar in Things for the Next list for example. (You also need to make sure, that syncing to-dos is activated for the subscribed calendar both in your as well as your spouses calendar.) Your spouse can now send you to-dos, by simply adding them to the corresponding calendar. Note however that subscriptions are read only. There is no way for you to change such a to-do in iCal. Not even by checking it off. No matter what you do in Things that would normally cause the item to change calendars, or be entirely removed from iCal, will have no effect.
• You can use applications like Anxiety to create a HUD style Today list that is always visible.

Chris did a great job in testing the new iCal sync feature. But with a feature like this, that can be used in so many different ways, it is quite likely that it is not yet void of bugs. Hope for the best, but expect the worst :).

If you were unlucky enough to open Things too early on Friday (depending on your time zone of course) downloading the new version from our web site didn’t even help. It stubbornly kept displaying this dialog. What were we thinking??? It is with shame that we must admit: there was not much thinking involved…

Here’s the scoop: all of this happened completely unintentional. The dialog was displayed by mistake, due to a wrong date that has been left unaltered in the application code. Later on Friday, we fixed this and downloading the new version resolved the issue.

Why do we have an expiration date in the first place? Some time ago when we began to release public development versions of Things, we figured that we didn’t want those development versions still be in use after stable release versions would have become available. And we did what every developer does with public development versions: we put an expiration date into the application. We used a very distant future date to make sure the release version would be available long enough to allow users to switch to the release version. Or so we thought… The reason why Things will be released later than we initially thought deserves a blog post on its own – iPhone anyone?

The dialog above is kind of OK. It tells you what happened and what you can do about it. It even offers to take you straight to our web site. But to tell the truth, we didn’t expect many people to see this dialog at all, which might explain why we didn’t take as much time and effort as we did for other dialogs. If we did, we would have made sure that a manual download wasn’t necessary. After all, we do have an automatic update mechanism, don’t we? Another shortcoming is the fact that it is not clearly stated that the user’s data is not affected at all. It wasn’t made clear that applying the update wouldn’t change the user’s data in any way, let alone delete it! This has certainly led to confusion among some of our users. Which brings us to an important topic.

Even though the whole thing was a mistake, there were quite a few users that were locked out of their data for several hours. From our point of view, this is one of the worst things that can happen. While Oliver Starr from GTD Times wrote a rather harsh article (and another one), speculating whether we are “insensitive” to our users need to have a “trusted system”, the exact opposite is true. We thought about this very aspect a great deal during the design phase of Things: How will users be able to access their data? What if they wanted to stop working with Things? How will they be able to export their data? And so forth.

All of this really boils down to one question: Who owns the data? There is only one correct answer to this question and it is obvious: only the user owns the data. Taken seriously, this answer implied that we as developers had to choose an approach as open as possible to store the user’s data. And indeed, this was a key priority for us from the beginning. We stated it on Things’ primary landing page even before this blog, the wiki, and the forums came into being.

To state this again very clearly, the release version of Things will save its data in an open, easy to understand and well documented, plain-text XML format. We chose XML because it is the most widely accepted file format for exchanging data between all sorts of software components. But at the same time, using modern style-sheet technology, ordinary users without any programming skills will be able to view these files nicely formatted in any web browser. It will be super easy for third parties to interoperate with the Things library by simply reading or writing small snippets of plain text files from and to the hard disk. Contrary to other solutions, like Apple Script for example, Things doesn’t even need to be running for this to work.

The development version currently available does not make use of the final file format yet. It does use a plain-text XML format, but a generic one (derived from Apple’s CoreData technology) which is easy to adapt for new Things features, but very difficult to use for third parties. The only reason it exists, is because it serves us well during the phase where Things’ data model is not yet fully complete. Of course, we have been working on our own easy to use file format all along and will roll it into future development versions as soon it makes sense.

A different matter, however, are pixel by pixel rip-offs. The software developer Panic, for example, has gathered a whole collection of those.

Yesterday one of our users (thanks Vitor!) pointed us to a complete rip-off of our current web design. It turned out to be the most blatant one I had ever seen. See for yourself:

I not only had quite some fun dissecting what the plagiator did do or rather didn’t do, I also learned a lot in the process. I am happy to present to you today our new tutorial:

1. Be sure to use the same color scheme. This makes Cultured Code users feel right at home.
2. Pay attention even to the smallest of details, like the little silhoutte icons in the navigation bar, the smaller dollar sign… Only cowards cover their tracks.
   
3. Treat inconsistencies with respect. The original designer must have had a reason to use Helvetica in the navigation bar and Lucida Grande for everything else.
   (Which reminds me of something I forgot to update when I changed the whole website to Lucida Grande…)
4. Don’t even think about changing one pixel of an icon. You don’t want to mess up someone else’s work. Also, keeping the same filename makes maintenance a lot easier in case the original website updates their graphics.
   
5. Paying hommage to Panic’s Transmit truck is a must for every serious rip-off artist.
   
6. If the original website doesn’t have a contact form to copy, create your own. It’s not that hard. You can do it!
   
7. And for those who still don’t get it: Leave one link unchanged to prove beyond any doubt, that you must have completely copied the entire source code.
   
8. Claim a copyright.
   

What can we learn from all of this? The bold variant of Lucida Grande looks kind of nice in the sidebar. We should try that too.

]]> http://culturedcode.com/things/blog/2008/05/the-highest-form-of-flattery.html/feed http://culturedcode.com/things/blog/2008/04/the-ical-sync-interface-or-how-to-implement-a-new-feature.html http://culturedcode.com/things/blog/2008/04/the-ical-sync-interface-or-how-to-implement-a-new-feature.html#comments Fri, 25 Apr 2008 16:48:20 +0000 Chris, Jürgen, and Werner http://culturedcode.com/things/blog/2008/04/the-ical-sync-interface-or-how-to-implement-a-new-feature.html We have just finished the user interface of our new iCal sync feature (or more precisely, support for Leopard’s system wide to-dos) and would like to share some screenshots. The screenshots are taken from a private development version. But before moving to the screenshots let us give you an idea of what it is like to implement a new feature.

Here is a list of steps we usually take when tackling a major new feature. We …

1. Evaluate all related feature requests.
2. Decide what will actually go into the new feature. This is a quite complicated step. We try to look at common usage scenarios. We also try to guess what the majority of users would need. Sometimes we postpone features because their implementation would take too long. An example is providing foldable pocket layouts for printing. We’d love to have it, but it didn’t feel right to make everyone wait longer than necessary before a fundamental feature like printing even shows up.
3. Try to find a unified point of view if the results of step 2 are too varying or divergent.
4. Try to think of ways how we could clearly communicate the ideas of 3.
5. Create Photoshop mock-ups of the user interface.
6. Start with the actual implementation of the interface and test it. If necessary, go back any number of steps and start all over again.
7. Create the engine or logic that makes the feature work.
8. Test-drive a functional implementation of the new feature for the first time. Go back any number of steps if necessary and start all over again.
9. Extensive bug testing and fixing.
10. Seed the new version and watch for related emails and forum posts. Fix bugs and make notes for future improvements.

With iCal sync we are now ready to move to step 7.

We had two requirements for iCal sync. On one hand, turning it on should be as simple as turning a switch. On the other hand, we wanted to take advantage of the existence of multiple calendars and make it flexible enough for usage with mobile devices and apps like Anxiety or Apple Mail. This requires that users are able to restrict syncing to different parts of Things like Focus lists, to-dos that have certain tags, Areas of Responsibility, or even projects. Obviously having both simplicity and flexibility seems contradictory. Here is how we are doing it.

When you select iCal in Things’ preferences for the first time you will see the simple variant of the dialog.



There you have it: the On/Off switch. Well, it is actually a menu and looks like this:



The most common requirement is to be able to export either all active to-dos (Next) or the currently pending items for today (Today), and to be able to import new to-dos created in other applications. When selecting either “Today” or “Next” from the sync menu this is exactly what you get.



If you need the full power of the underlying engine then choose “Custom” to transform the simple variant of the dialog into the advanced one:



The text fields offer auto completion and only accept valid input. It is possible to drag tags, projects, or areas to these fields.

We believe that the advanced variant of the dialog puts an amount of flexibility at your fingertips that compares rather favorably with the competition. However, there are still more feature requests related to iCal which didn’t make it into this version. But never worry, Things will continue to be improved at full speed well beyond the 1.0 release.

If you would like to comment, instead of sending us email, consider to use the comments section of this article or even better the forums. Your feedback will be much more valuable if your fellow users are able to read it too and respond to it.

]]> http://culturedcode.com/things/blog/2008/04/the-ical-sync-interface-or-how-to-implement-a-new-feature.html/feed http://culturedcode.com/things/blog/2008/04/things-091.html http://culturedcode.com/things/blog/2008/04/things-091.html#comments Wed, 02 Apr 2008 15:48:48 +0000 Chris http://culturedcode.com/things/blog/2008/04/things-091.html The biggest new feature of Things 0.9.1 is native printing. Until now we only had Mac OS X’s built-in printing support. But since Things’ to-do lists are optimized for the screen rather than paper, the results were less than desirable.

When choosing Print from the File menu, Things 0.9.1 will construct a dedicated print document which is displayed in an extra window. Before continuing with Mac OS X’s standard print dialog users get a chance to customize the document in the following ways:

• Decide whether to print the entire list or just selected items.
• Change the font size. Note that since the print document on the left does not (yet) represent the actual width of the paper, the text may appear to be larger than the actual result on paper.
• Decide about the visibility of notes. If your list contains long notes that you do not want to print entirely, you can also choose to limit them to 8 lines of text.

Clicking the Print button will then invoke Mac OS X’s standard print dialog. Particularly interesting is the Layout pane. Using the Layout pane you can arrange multiple pages on one sheet of paper.

As an improvement we plan to combine our dialog with some options from the standard print dialog to create what Apple calls the Simplified Print Dialog. The idea is to have one single simple and uncluttered dialog that suffices in most situations.

Things 0.9.1 also contains the following fixes and improvements (from the Release Notes):

• Repeating items. Fixed a bug that resulted in “after completion” option not working properly.
• Repeating items. Resuming a previously paused item no longer crashes Things.
• Quitting Things before closing an edited item no longer results in loosing the most recent changes.
• The Things library is writen to disk more often now (after each edit).
]]> http://culturedcode.com/things/blog/2008/04/things-091.html/feed http://culturedcode.com/things/blog/2008/03/things-0901.html http://culturedcode.com/things/blog/2008/03/things-0901.html#comments Tue, 18 Mar 2008 16:18:34 +0000 Jürgen http://culturedcode.com/things/blog/2008/03/things-0901.html The new release contains 12 bug fixes and improvements related to features we introduced in version 0.9.

A notable feature of Things 0.9, that didn’t get enough attention last time, is the new bug reporting dialog. Things 0.9 is very eager when it comes to reporting errors. In fact, a little too much so. Every little error message was promoted to a crash. This is great for developers because we get a lot of error reports and have the chance to improve the reliability of Things quickly. On the other hand, some users who never saw Things crash now did so for the first time.

We remedied the situation in the following way. Things will still offer to send an error report even when uncritical errors are encountered. But the error report dialog no longer forces the user to quit the application.

We want to apologize for the inconvenience and thank everyone who sent error reports.

]]> http://culturedcode.com/things/blog/2008/03/things-0901.html/feed http://culturedcode.com/things/blog/2008/03/things-09.html http://culturedcode.com/things/blog/2008/03/things-09.html#comments Sat, 15 Mar 2008 12:44:45 +0000 Jürgen http://culturedcode.com/things/blog/2008/03/things-09.html The most substantial improvement in version 0.9 is, of course, recurring to-dos and projects. See below for an entire post describing this new feature.

Here is a list of some of the other improvements:

Choose Things Library

This is clearly an advanced feature that should be used with care. When holding down the option/alt key while opening Things, a dialog will be displayed that lets you either create a new Things library or choose an existing one. This feature is practically identical to a similar one in iTunes.

You can now store your library in a place that might be more convenient for your backup routine. Choosing a web-based location is not possible.

This feature is probably most interesting for people who would like to carry their Things library with them. Plug in a portable or USB flash drive and move your Things library from its default location Home/Library/Application Support/Cultured Code/ to that drive. Move the entire Things folder and don’t forget to quit Things first! The next time you open Things, it will ask you for the new location.

Better error handling

Things will now catch more unexpected errors and also offers a convenient way to send reports via email. Due to some limitations in Tiger this feature works best on Leopard.

Duplicate

There is a new Duplicate menu command in the Edit menu.

Scheduled

The Postponed list is now called “Scheduled”. There are a couple of improvements here. Since the Scheduled list will be the home of our recurring item templates, “Postponed” no longer seemed appropriate. But more about this in the post below. Scheduled now uses relative dates and groups items under headings like “Next week”, “April”, etc.

Move to Today

When an item is postponed, there is an option to automatically move it to the Today list on the specified date.

There are also many bug fixes, some of them quite substantial. More details can be found in the Release Notes.

]]> http://culturedcode.com/things/blog/2008/03/things-09.html/feed http://culturedcode.com/things/blog/2008/03/recurring-tasks-xxl.html http://culturedcode.com/things/blog/2008/03/recurring-tasks-xxl.html#comments Sat, 15 Mar 2008 12:40:55 +0000 Jürgen http://culturedcode.com/things/blog/2008/03/recurring-tasks-xxl.html Early on many users told us how important an implementation of recurring tasks would be for them. Having always (mis)used iCal events for recurring tasks myself, I hadn’t seen the need for a corresponding feature in Things. So much for what difference user requests can make :). And I finally noticed that hacking recurring tasks via iCal events isn’t that great after all. For some weeks now I have been looking forward to manage my recurring activities properly. And now I can.

When implementing recurring tasks one basically has the choice of either doing a primitive version like “every x days/weeks/months” or doing it in a really flexible and powerful way: enter Things 0.9.

Let’s look at an example: mortgage payments. Things allows rules like “Mortgage payment is due on the last day every month. Remind me 3 days in advance.” For the most part of the month you really don’t need to think about the payment. In that respect recurring tasks are no different than other postponed items except that they automatically repeat. It is thus natural to let the Postponed list handle recurrence. And since the term “Postponed” didn’t seem appropriate anymore we renamed it to “Scheduled”. This is how it works:

The Scheduled list

The Scheduled list does not contain the actual to-dos you are eventually going to check off, but it contains templates instead that are used to create those to-dos. This approach has a number of advantages:



• The Scheduled list gives you a great overview of all your recurring activities. They are nicely organized by interval and provided with descriptive labels. Together with single postponed items, the Scheduled list contains everything you needn’t be concerned with just now, but will be brought to your attention on the specified dates in the future.
• Since recurring items live in Scheduled, they don’t clutter up the lists you are working from. Instead, on the dates you specified, copies of the relevant templates are made and put into the Today list. Once completed those tasks will be logged getting out of your way until new copies are created.
• Since the actual to-dos are completely independent from their templates, you can edit them as you wish. For example, let’s assume you want to do monthly reports that always have a certain structure. You can put an outline of that structure into the template’s note section. Every month a copy of the template is made. Consequently, each copy will already contain your outline. Each month you can then fill in different details. All monthly reports will eventually go to the Logbook where they can be review as needed.

Creating new recurring tasks



You can create a new template in Scheduled by clicking the toolbar button “New Repeating”.



Or you can turn an existing task or project into a repeating one by editing it and using the action gear button at the bottom right of the item.

Recurrence patterns

There are many options for creating recurrence patterns. For example, use “After Completion” for tasks like “tidy up desk” that don’t depend so much on the calendar, but on the last time you’ve completed them. And on Leopard you can even use iCal events as a pattern (think “Birthday calendars”). Projects can be made repeating too (check lists).

Implementing recurring tasks like we did was significantly more complex than we anticipated. But I believe it was worth the wait. If I am not overlooking something here, then we now have the most powerful recurring tasks implementation available. And I hope you like it.

We’ve gone to great length to ensure that most bugs are fixed already. But with a complex feature like this one, it is quite likely we didn’t catch everything. Please keep a close eye on it and make sure it is working as you expect. And when it doesn’t, choose Things > Provide Things Feedback… from Things’ main menu and tell us what happened.

]]> http://culturedcode.com/things/blog/2008/03/recurring-tasks-xxl.html/feed