Step 2 – the plan

Now you know what you want to do, and with which tools.

Don’t start coding yet, though. Let’s get things organized first. Let’s write lists!

This part is very important, because it weill help set goals (milestones) you stay focused on.

Oh, and since I cannot be bothered to write WeeDUplicateDetective too often, I will

Feature list

1. Write down a very simple and high level list of the main features you want to implement.

For WDD:

  • Input folders to be scanned
  • Scan folders for duplicates
  • Present duplicates in tree view
  • Give several options for the selection of duplicates to be cleaned
  • Preview some select file types
  • Offer different sortings of the tree of duplicates
  • Allow searcing the tree of duplicates
  • Clean the selected duplicates
  • Use WPF animations capabilities

Looks simple, right?

2. Break down the features into more detailed features. Actually, it’s now time to have a more detailed idea, on the technical level, of what you want to achieve.

How you’ll achieve it is a different question. To be answered later

For WDD:

  • Input folders to be scanned
    • input can be done with Browse button and drag’n drop
    • allow reordering of the list
    • allow removing an item
  • Scan folders for duplicates
    • scan using a different thread
    • allow stopping the process
    • Criteria for duplicate: same name, same size, same content, same creation date, same last modification date
    • show progress
  • Present duplicates in tree view
    • tree items can be individually selected
    • the tree view need columns to display the file name, file path, etc
    • the tree has only 2 levels
      • level 1 – the first found occurance of duplicates is a node on the root
      • level 2 – all other subsequently found occurences are its children
    • Show hown many duplicates the original has
  • Give several options for the selection of duplicates to be cleaned
    • how to select:context menu + specific area (radio buttons?)
    • what to select
      • all except the original
      • only the last copy
      • only the original
      • all except the original and the first copy
      • all
      • depending on the search pattern
  • Preview some select file types
    • pictures
    • videos
    • music
    • text documents (text, html, etc.)
    • MSOffice / OpenOffice documents
  • Offer different sortings of the tree of duplicates
    • order by file name, file path, file size, number of duplicates, etc.
    • 2 levels of ordering: order only the originals, or order the group of duplicates (modifying, if necessary the item considered to be the original), and then the originals
  • Allow searching the tree of duplicates
    • find first / find next
    • allow searching in file names, path, date, size, etc. or all
    • offer operators
      • example: search for “file size” “bigger than” “123456”
    • found item is selected and brought in view
    • info message to be displayed when the end of the list is reached
  • Clean the selected duplicates
    • 3 clean-up modes
      • send to recycle bin
      • delete
      • move to another folder
        • allow user to choose the folder
    • show progress

Humpfngnghh, already much longer…

Do you see now that the task is not as small as you first thought? On the bright side, this is now when you start getting to see the product, you start already thinking about the next step.

Since the scope of the project is still, nonetheless, small, you do not need to go further down in granularity: you do not need to break down features into specific, deeply technical tasks.

This can become a good idea though when you’re implementing a big feature and want to keep track of the order of implementation, of the propgress, etc.

Milestones, Releases and Priority list

In order to stays focus you have to set goals. Milestones, as I known them.

The first milestone will be a prototype, for the main features. The next one will be more polished, until you get feature complete for a specific release.

A release is a specific milestone. It means you have reached a pre-defined number of features and if you have readched a satisfying level of quality.

The priority list will not just help you get an overview on milestones and releases, but also to organize in which order the separate tasks defined in the detailed feature list above should be implemented.

Again, the perceived overhead of organization will help you stay focused.

For WDD I have four levels of Priorities, from most important (1) to less important (4)

  1. must be fixed / implemented for the next Milestone
  2. must be fixed / implemented for the next Release
  3. should be fixed / implemented for the Release coming after the next release
  4. for a later, future release

Inside each priority level, you should, to the best of your knowledge, already organize (this word again, let’s use another one) sort the tasks by preceding order.

This means something simple: a house cannot build build in any order. You cannot install the windows roof before you have the walls (or at least some structure to hold the window frames).

For WDD: I should not implement the scan process before I implement the part where you give the folders to scan. Indeed, how can I check my implemnetation if I have no input?

Let’s see the ordered list for WDD:

  1. Prio 1 – Milestone 0.9.0.0 (alpha)
  2. Prio 2 – Release 1.0.0.0
  3. Prio 3 – Release 1.5.0.0
  4. Prio 4 – Release 2 and later

Nota: this plan does not show WDD 1.1, why was it released then?

Well, not everything is always perfectly planned, and such a small project can be flexible. Besides, WDD 1.1 fixes an important issue , and reactivates stuff I removed in 1.0 because I hadn’t found a way to have it work then, but still were satisfied enough with the product to release it.

User Interface

No list here. Yay.

What you’ll need though is a pen and paper. Whether “analog” or digital, you need a way to sketch up the user interface.

Here are a few tips:

  • you’re not just making the app for you, you want others to use it and like it as well
  • who is your target: advanced users, mainstream users?
  • organize the workflow
    • What is the most important information that the UI has to communicate?
    • how does the user navigate from one UI area to the other? Why?
    • group what goes together
    • allow hiding / showing the less used stuff
    • grey out or hide disabled controls? (grey out is often better)
    • make sure the most important parts are easily useable and accessible (very few clicks)
    • make sure the sensitive and potentially dangerous parts are difficult to access (lots of clicks)
  • carefully chose colors
  • decide how visual your app should be
  • check similar projects and improve or reproduce what you like, and improve or get rid of what you do not like

You will need two more lists, but they will be useful only when you start coding, so let’s forget about them for now.

Todo List

Bug tracking

next steps:

  • software architecture / coding
  • usability
  • testing and debugging
  • installer
  • hosting
  • publishing
  • follow up and maintenance
  • last word: discipline

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s