What are the recommended techniques to get the fastest completion time? Just an example, a project has 6 tasks:
Apps to solve this problem would be great!!
A simple scheduling tool like MS Project will help you do this. You can do this on a whiteboard but even with simplest networks the chance of a calculation error is rather high...that might just be me.
The path to examine is the critical path, the longest duration in the network. Once you have established the resource and task dependencies and linked the work packages, the critical path will materialize and you can easily see what alternatives you have in sequencing. Obviously, those packages that do not have a clear task or resource dependency are what can move more easily.
Loading your example in a scheduling tool, your planned duration is 8 days with task 2 and 6 on the critical path. Task 1 and 2 are the only ones without a dependency so these are your only options as to which to start first.
In order to get early feedback, you shall start with the most important task that has the shortest execution time. With this way, you'll get fast feedback on your work, and you'll also red the risk on working on something which may not be not important.
The technique you're after is critical path analysis. I find it's usually quicker to just do on a whiteboard rather than using software unless you have lots of tasks with lots of dependencies.
There's an overview over at Wikipedia. http://en.wikipedia.org/wiki/Critical_path_method
That said, in the event that you have enough dependencies between bits of work that doing this sort of analysis is worthwhile, it's generally better to look at breaking the work up differently in order to make each chunk independent (or at least to remove as many dependencies as you can) and then just starting with whichever activity gives you the most value or, as Zsolt suggests, the quickest feedback.
This is particularly true if there is uncertainty on the duration of tasks. If each task is being completed by a machine (in automated manufacturing for example) where you have high certainty on how long the activity will take, focusing on the critical path is sensible. In software however, we often find that our estimates aren't that accurate which makes focusing on the critical path more dangerous since it has a tendency to be in flux.
You've stumbled upon the problem of task scheduling. As long as you have just one resource at work, it's not very hard to solve - you just start whichever task can be started.
It gets more tricky when you have multiple resources used to accomplish tasks. Then it becomes the resource constrained scheduling problem, sometimes also called resource leveling. You can find a good intro to this problem, and a review of possible solutions, here.
In short, it's a tough problem to solve completely, as it is a NP-hard problem, which means finding the optimal solution for large project is simply not feasible, you can only find a good approximation of the optimal solution.
Some PM tools, like Gigantt, provide automatic task scheduling. You just describe to the system how tasks depends on each other and it finds a good scheduling solution.
Start with task 1 and 2 since they don't have predecessors, as David Espina said. Note when they finish. Now you have task finishing at day 1, task 2 at day 2. (active task #1 at 2; #2 at 2).
Then repeatedly 1. Find the first active task to finish. Here task 1 at day 1. 2. Look at which tasks can now be done. Here that is task 4. 3. Figure when it will finish. That will be day 3. 4. Update the list of tasks. Now you have (#2 at 2, #4 at 3) active.
Then at day 2 task 2 finishes. You can start task 3 and 6. Now you have (#4 at 3, #3 at 5, #6 at 8).
Next task #4 finishes at day 3, but you can't start anything more. That means task #4 isn't on the critical path.
Next task #3 finishes at day 5. You can start task 5 finishing at day 6. Active: (#6 at 8, #5 at 6).
Next task #5 finishes. No new tasks to start. That means task #5 isn't on the critical path. Active #6 at 8)
Next task #6 finishes at day 8.
The last task is on the critical path. Then go backwards. It started when #3 finished, so #3 is on the critical path.
Task #3 started when #2 finished. So #2 is on the critical path.
Task #2 didn't have a predecessor, so it is on the critical path.
