*This is an application that will be developed as a Metro App and a Windows 8 Desktop app, I would like Sharpy to be included in two categories: the "Productivity" section of Windows 8 ("desktop") apps and the Windows 8 Store (metro) apps.
Sharpy is an application where users create tasks for others to accept and complete. It uses the new Metro application capabilities so a user can create, manage and monitor tasks with a minimal number of actions. It leverages the new Metro notification capabilities in a way so the user can easily manage and follow up tasks. Actions and navigation can be easily taken if a touchable screen is used. The user interface is designed with large icons and tiles so fingers can be used instead of a mouse pointer. It is designed for mobile devices, an ultrabook is an ideal device but it would also work well in an smart phone.
The application is developed in C# using XAML. Windows Notification Services and Push Notifications are used to provide updates when a task changes state or new tasks are assigned or sent to other users. The application permits to assign tasks to multiple sharpies (contacts that must complete the task) and owls (contacts that want to get notifications of the task state).
For the application back-end, I will use the patterns I covered on my
previous articles in CodeProject so the domain and persistence components can be implemented in a flexible manner decoupling the client side from the back-end. In this way I can rapidly develop the application and then a later stage provide a proper back-end that could work well with cloud services. Further details regarding these patterns and design can be found in the mentioned CodeProject articles.
The idea is simple, is it just me or sometimes when people are asked to do something, they just forget about it. So why not to provide an application where the person asking takes the responsibility of creating the task in first place; they normally do
it anyway in the form of a call, text message, email, whatsApp and so for.
So the proposed solution is to amalgamate the whole process, that is: request and
actioning in just one simple application where both sides can easily notify
each other when a task is created or changed. The application defines two sets of task users: sharpies and owls. The sharpies need to acknowledge
the created/received task and complete it before is due; the owl users can monitor the acknowledges and task completions. Simple, isn't it?
The Sharpy application provides an easy way for everyone to interact, manage and monitor these tasks taking advantage of Windows 8 and the new Metro application functionalities.
The Sharpy application is still in a design stage, this article will be modified as new application artefacts are created, so expect many updates over the upcoming weeks. The goal of this
first version of the article is to address the scope of the application, high-level design and describe which technologies the application will use.
But it is still early days so if you can think of any feature that you might want to see in the application, let me know, place a comment
at the end of the article and we will take it from there.
The included source code is in a early stage of development, it is just a poor mock of the screens. I just focused on the designed of the client models and the pages. It is missing the business domain model and some of the main screens. But it is a start and it is not too bad for couple late nights of work.
Sharpy design UI is all about ensuring that the app is touch aware. All actions can be done with the fingers and the screens are designed following the Metro guidelines for this sort of applications.
For the notifications side, the idea is that ultrabooks are a very portable device that people carry with them. I will use the smart connect support so users can get notifications even in the case the device is sleeping.
I am also planning to have a look at the Identity Protection Technology capabilities and use it when the app needs to connect to the Sharpy Cloud services.
Application Scope - Functional Requirements
There are two main entities in the application: contact and task.
Contacts are authorised Sharpy users that can create tasks and assign to other users. The following functions will be available:
- Contact details
- Search for contacts
- Send invitations
- Accept invitations
- List of friends
Tasks are actions that users create and assign to contacts. The following functionality is required for tasks:
- Task details
- A user can create a task indicating start and due date/time
- The user can add sharpies to the task who will need to accept and complete it
- The user can also add owls to the task so they get notifications and follow when
tasks are complete
Sharpy uses the new Metro tile notifications to inform the user of Sharpy events:
- Invitation requests
- Accept tasks
- Notify changes of tasks assigned to other sharpies
- Overdue tasks
Sharpy uses the following notification mechanisms:
Those are the information and notifications that you can see directly through the application tile
Toast notifications deliver transient messages outside the app to get the user’s attention immediately. They are intended to be used only when the Sharpy application is not active.
A badge is a summary or status update concerning some application notification
In order to notify users of actions taken by other Sharpies, the application requires to use Push Notifications and Windows Notification services from the cloud which is new functionality for Metro applications in Windows 8. In a nutshell the Sharpy Notification design is as follows:
Application User Interface - Screens
The main screen provides access to three main functions:
- My Tasks
- Create new task panel
Summary data in relation to the state of tasks is displayed in the Sharpies tile, it also displays the last task notification
that has been registered. I am using icons to indicate the task state: Pending confirmation/acceptance, ToDo and Overdue.
The 'My Tasks' tile displays a summary of tasks that other sharpies have created and assigned to me, so they are the tasks that I need to complete. The tile also displays a set of summary state counters, similar to the ones that the 'Sharpies' tile that I just described. The last section, the textbox and button, provides an easy way for creating a new task, once the 'SEND' button is clicked the application takes the user to another helper window to enter other details like due date, sharpies and owls.
ToDo: I need to prototy the Task Creator window.
This is the screen that the user uses for monitoring the tasks assigned to others. The design uses chunky images and tiles so it is easy to navigate and take actions; displays and navigating among sharpies and their tasks is just a couple of 'finger clicks'. This screen is divided in two sections:
- Left side: List of sharpies that have tasks which the user has subscribed to, please note that the task creator is
automatically assigned as an owl for the task.
- Right side: List all the tasks for the selected sharpie.
The design is kept very simple, even kids should be able to use these screens.
As it can be seen above, the sharpie title provides a summary detail with a description of the first task to accept/complete and a set of task state counters; sharpie tiles are sorted by the task due date or creation date depending on the task state.
For the section on the right side, as it can be seen above, tasks are sorted by the due date/creation date. Each task displays the last time an action that was taken. Some actions could be added, for example, we may want to send a reminder notification to a sharpie if we noticed a task is overdue.
My Tasks Screen
This screen is very similar to the right panel that is used in the Sharpies screen and I just described. A list of tasks assigned to the user are displayed
and sorted by due date and state. The user in this screen is able to accept tasks created by others and complete them. Again, usage is facilitated by the touchable screen for navigation and manipulation of the tasks.
ToDo: In the next article update I will include a prototype screen of this function in the application.
Sharpy is a simple solution for a common daily problem, with a slick and friendly UI, a touchable screen device should make the use of the application a very pleasant experience; even kids will master the application if few minutes. The new notification mechanisms included in the Metro applications enhances the application capabilities ensuring users are alerted when tasks are due and when others are completing tasks.
The competition is a fantastic idea, personally I was wondering what to look/do next, I had some ideas for Windows Phone but because the Windows 8 SDK was not available I was thinking of looking at Android. Then by a chance, I heard about the competition last Thursday 18th Oct. Only on Friday I was opening Windows 8 and VS2012 for the first time. Although I have some years of experience with XAML, I did not expect to be able to do so much in so little time. I am very impressed, it is very exciting, MS has done a really good job with W8 and VS2012.
22 Oct - First version of the article submitted - missing some sections and source code
23 Oct - Reword some of the article content
24 Oct - First basic version of the source code was included - v.01
24 Oct - Indicate competition categories and ultrabook technologies that the app will use
25 Oct - Added v02 of source code download:
Source code cleansing -- still a WIP but getting there
Sharpies screen now shows correct tasks when a sharpie is selected