The reason for the change is that after a year, I still haven’t found the bandwidth to set up the 503(c) corporation with the state of Illinois, recruit board members, and secure funding for the new entity. Fortunately, Audacious Software is on very good financial footing and can provide the resources required to move forward with ubiquitous context-aware computing. This move is intended to make my life easier and when my life is easier, more code gets written.

Thanks for your patience, and I’ll see you on the other side.

This release fixes a handful of bugs, updates the interface slightly, includes support for AppleScript, and introduces the new Calendar view.

I’m still working on the documentation, so please take a look at the initial introduction to get started. I will also post a follow-up blog post that describes the new features in more detail.

If you have any ideas, suggestions, or bugs to report, please post them in the comments below.

Thanks!

Work on the assistive technologies (Task Views & Shion + Pennyworth) has been steady and I’m hoping to release some updates to Pennyworth client applications soon.

Not too much has changed with Pennyworth proper. After some consideration and given some future projects coming down the pipeline, I’ve begun planning out Pennyworth 2.

In short, PW2 will be a re-implementation of the Pennyworth architecture designed to work on multiple platforms and devices. The plan is to implement the core of the system in cross-platform C and use native languages and tools to wrap the core in a user interface that “fits” on the platform.

I’m taking this approach (as opposed to the older approach of rewriting the system by scratch for each platform) for a couple of reasons:

1. As a solo developer, I don’t have the time or energy to manage and support full ports to each platform in each respective language. Assuming that the average size of a Pennyworth port is N lines of code, and I port it to P platforms, I need to manage N * P lines of code. This is too much code to maintain and continuously debug.

2. While some code will necessarily be unique to each port, I believe that the bulk will be portable across platforms. If 25% of the Pennyworth code is generic in this sense, the amount of code to manage becomes 0.25N + 0.75P By keeping N somewhat constant and only growing the P, the software development side of things will scale better as I add support for each platform.

The current Pennyworth implementation has approximately 10000 lines of code. Of that code, about a third (0.33) is a good candidate for the platform-neutral core. Using the assumption that other implementations will have a similar amount of code in the same proportion, the project will scale in the following way:

1 port: 10000 LOC (both old approach & new approach)

2 ports: 20000 LOC (old) vs. 16700 LOC (new)

3 ports: 30000 LOC (old) vs. 23400 LOC (new)

4 ports: 40000 LOC (old) vs. 30100 LOC (new)
(The 4th port is almost free when compared to the older system.)

5 ports: 50000 LOC (old) vs. 36800 LOC (new)

Since I have more 3 ports that I would like to implement, this change makes sense.

3. I also believe that sharing the core code will allow me to implement a more robust and efficient system across platforms. By including resource-constrained devices (such as mobile phones) to the mix, it easier to notice inefficient and unstable code.

To be honest, this effort is in its early phases and I probably won’t have anything ready for testing until later this year. However, I do think that the short-term pain will result in long term gain as I develop a framework and approach for getting Pennyworth on more devices.

Thank you for your patience.

This is a minor bugfix release that addresses a handful of issues with Windows XP.

Thanks for giving the software a spin and let me know of any bugs or other issues in the comments below.

This is the first public release that includes support for the list, cloud, and histogram views. This version of the software is also compatible with iCal, OmniFocus, Things, Basecamp, and FogBugz.

I’m still working on the documentation, so please take a look at the initial introduction to get started.

If you have any ideas, suggestions, or bugs to report, please post them in the comments below.

Thanks!

The application is called “Task Views” and it attempts to solve the problem that modern workers face when managing their tasks and todos. There are a variety of great task management applications (desktop and web alike), but the realities of the modern workplace is that we find ourselves using a variety of solutions to attack the same problem: getting things done.

In my own personal life, I use FogBugz to track software tasks, a Basecamp site to collaborate with clients, and OmniFocus to handle everything else. The problem with splitting things up in this way is that it leads to tunnel vision. When I’m working in FogBugz, I’ll plow through a variety of software issues, while forgetting to pick up groceries on the way home. When I’m in OmniFocus, I find it easy to overlook urgent tasks for my Basecamp client. I get things done, but often find my triumph short-lived as I discover that I didn’t do everything I needed to do, simply because I forgot to look at my other task applications.

Task Views solves this problem by offering a set of unified views that transcend individual systems. The program accomplishes this using conduits. A conduit is a bit of code that pulls tasks from another system, normalizes the fields, and imports it into the current system.

Task Views currently talks to OmniFocus, Things, iCal, Basecamp, Entourage, and FogBugz. (Support for other systems is in the works.) The conduits fetch task information and dump it into a local database.

The program provides a very basic list view that allows users to quickly identify and view individual tasks. However, as the image above shows, this list can grow really long, really quickly. To alleviate this problem, Task Views provides a filtering function that allows users to select subsets of the database:

Users can construct elaborate filters by using simple Boolean rule-based logic.

The list view shows the main weakness of the current crop of task management applications. Almost without exception, all of them use a list metaphor to display what needs doing. Even on the largest monitors, tasks scroll off the visible screen rather quickly.

A cloud view provides a simple way of displaying more content in a more space-effective manner. Where as the list above shows less than a hundred items, the cloud view shows over seven hundred. However, the items are so small, that this view is clearly suboptimal.

Task Views allows the user to bind the size of the text to a numeric or date value associated with the tasks. In the screenshot above, the date the tasks were created is bound to the text size. Tasks created farther in the past appear larger than more recently created items.

Categorical and text values may be bound to the color of the text items. In the screenshot above, I’ve bound a variety of colors to various projects. Color makes salient which projects need more attention than others.

In addition to the list and cloud views, Task Views also provides a histogram view of the task space.

The view above shows the number of tasks associated with particular projects. As the cloud view demonstrated, I have many tasks still associated with the Jarvis project.

The histogram view also provides a useful temporal perspective of the task space. In the image above, the height of the bars represent how many tasks were created on a given day. This could as easily show how many tasks were completed within a particular duration in order to better understand personal productivity patterns.

Not pictured above are the task update notifications. Task Views periodically refreshes itself and when a task changes, the application will alert you using an unobtrusive Growl notification. This is useful for discovering that a coworker has elevated the priority of particular item without taking the time to inform you.

In upcoming releases, I plan to add new views that draw upon the data visualization research and literature.

The Context Angle

Since this blog is focused on context-aware computing, there is a context angle here. I speculate that while Task Views provides a variety of views and configurations, not all of them will be appropriate in all cases. A large histogram view may be useful for when the user is planning their week, but a smaller cloud view my be more appropriate throughout the working day. Task Views is explicitly designed to be dynamically reconfigured using systems like Pennyworth. Currently, the context-sensitive portions of the application are

1. The active filter: The list of visible tasks may vary with the current activity. For example, when programming, show the incomplete items from the FogBugz database. When collaborating, show items from Basecamp. When planning the upcoming week, default to OmniFocus.

2. The active view: A larger histogram is useful when explicitly planning. When doing other things, a more ambient cloud view may be more effective.

3. Individual view configurations: Date histograms may be more effective when planning, while categorical histograms may be more effective when triaging. In some cases, it may be useful to bind the size of the text in a cloud view to the date, in other cases, priority.

At the moment, I’m in the process of prototyping and testing this system with users with ADHD. If you’re interested in testing it yourself, post a note in the comments and I’ll get back to you. The software isn’t quite ready for release yet, but I am interested in recruiting more testers.

Second, I wanted to share some details about new Pennyworth work and how things will proceed moving forward. There are some big changes afoot, and this post describes how the project will move forward.

As some of you already know, I am leaving my graduate program at Northwestern University in order to pursue a full-time job as a software entrepreneur. My new venture is called Audacious Software and I’ve been busy over the past couple of months putting together a new company. The work isn’t complete, but progress is steadily being made.

The original plan was that my new company would continue Pennyworth development as a research activity. I’m still a strong believer in the idea of context-aware computing and I have concrete plans to develop and market a variety of context-aware applications and services in the months ahead. However, after some discussions with other people, I came up with the idea that the Pennyworth work should be its own separate entity in order to make collaborations with others simpler and more efficient. Consequently, I’m in the process of setting up a non-profit corporation to manage and hold Pennyworth and other related properties. I’m using the same model followed by many other open source projects, such as Mozilla, Software in the Public Interest (Debian), and FreeBSD.

My goal in establishing a standalone entity for Pennyworth is to engage other parties interested in collaborating on context-aware technology so that we can collectively put this technology in the hands of users everywhere. Audacious Software is the first sponsor of this work and I hope to find other companies, universities, and organizations willing to partner with in the months ahead. I’ll post more details about this as they become available.

So, what activities will this organization pursue? At the moment, there are three:

1. Continue the Pennyworth and Jarvis work to create and distribute a robust context-inference system for Mac OS X and Windows desktops.

2. Develop and distribute a variety of “example” applications that demonstrate how to use context effectively and spark others’ imagination about what’s possible with using context.

3. Continue to research how to better sense and distribute context in new environments. This includes mobile platforms (iPhone, Android, Maemo, etc.), alternative operating systems (Linux, *BSD), and emerging computing platforms (Chumby, Arduino, etc.).

In the weeks ahead, I plan on resume posting to this weblog regularly so that the work I’ve been doing becomes more visible to outside readers. In the chaos of starting a new company (or two) and managing the transition from graduate school to startup, my updates became less frequent than I would have liked. To make for this, I have a series of posts in the works that should hit all three points mentioned above.

Because of some of the major bug fixes in this release, please remove any previously-installed versions of Jarvis using Add/Remove Programs in the Windows Control Panel.

Now onto the major changes:

1. Jarvis now has a proper installer that allows users to choose where to install the application.

2. The installer adds a shortcut to your Startup menu. (Delete this if you don’t want Jarvis to start on login.)

3. The installer checks for the appropriate Windows prerequisites (.Net 3.5 & Windows XP service pack 3 or greater).

4. The first pass of the user interface is complete. The Rules and Learners interfaces are complete and functional, and I’ve added new preference options for configuring the training hot key and manipulating the machine learners.

5. I’ve fixed a variety of bugs that cause crashes on startup.

This is still an incomplete release in that it talks to few applications to collect context information and still has no way to automate other applications in response to changes in users’ environment. These will be focuses for the next release cycle.

Thanks for giving the software a spin and let me know of any bugs or other issues.

First of all, I am going to try and release a new version every couple of weeks. I’m planning to push out another public release two weeks from yesterday.

Priorities for Jarvis 1.0b2:

1. Correct the bugs reported in 1.0b1. I already have a bug filed for a hot key issue on XP.

2. Implement the rules interface. This is the Windows equivalent of this.

3. Implement an interface that exposes a visual representation of the machine learner. Pennyworth uses a nested set diagram for this purpose, but I’m planning on using something more akin to a flowchart for Jarvis. The functionality lets users see the model that the system constructed to predict context and this allows them to be better “teachers”.

5. Finish implementing the preferences interface, including options for manipulating the learners.

6. Misc minor UI tweaks.

7. Add pruning to the C4.5 decision tree algorithm.

8. More application sensors. Particularly, Firefox & Chrome “current web site” sensors.

This is a tall order, but one that should be achievable in the next two weeks. Don’t forget to send any feedback of your own to jarvis@aetherial.net.

Thanks!

From an e-mail I sent out earlier today:

You’re receiving this mass message because I’ve been in touch with you about the Windows port of the Pennyworth system (or you belong to one of the NU mailing lists).

I wanted to let you know that while I’m several days late, the Windows port of the Pennyworth architecture is now online at

http://pennyworth.aetherial.net/jarvis/ 

Jarvis represents my initial efforts at bringing the context-sensing approach embodied in Pennyworth to the platform(s) that the rest of the world is using. :-)

This is a very early release and at the moment, it can observe you, learn context models from your corrections, and predict your context in real-time. That’s about all that it does at the moment. In next several weeks, I will be adding new features and functionality in order to achieve feature parity with Pennyworth.

The current missing features include:

• The ability to modify other applications based upon context changes.
• The ability to solicit context information from other applications.
• The rules interface for overriding the machine learner.
• An interface that exposes the learned context model for inspection.
• Application auto-updating.
• Sharing context to networked clients (including Pennyworth).
• The ability to tweak or reset the machine learners.

My main goal in releasing this initial version is to begin to identify any brittleness in the system that may be a result of any of the combinations of hardware and software that you use. In other words, this is the “test and see if it crashes on others’ machine” release. If all goes well and the current set of functionality is stable and responsive on your systems, I’ll move onto the next steps of adding the missing functionality above.

I’m quite excited to be working on this and I’m looking forward to receiving your feedback on Jarvis. Ideally, I’ll be able to turn your feedback around quickly and do a series of releases every couple of weeks between now and June. By June, I hope to have iterated the system enough times that it’s as stable and full of features as Pennyworth. Once I’ve achieved that goal, I’ll be in touch with some of you to talk about how we can make Jarvis talk with your applications in order to start building a smart context-aware Windows environment.

Thanks for your patience, and please let me know what you think.