Construction CPM Conference 2019 – Schedule Logic in Microsoft Project

Click Here to view the screen and audio capture of my presentation (on BPC Logic Filter) at the 2019 Construction CPM Conference.  Fred Plotnick (the Conference organizer) is kind enough to host the content on his server.

Most of this will be familiar to those who’ve already seen one of my presentations on BPC Logic Filter, but the questions and answers beginning at about minute 59:00 are new.

Driving Logic in Backward Scheduled Projects (Microsoft Project)

In MSP, a “backward scheduling” mode – sometimes called backward planning, reverse scheduling, or reverse planning – can be invoked by scheduling the project from its finish rather than its start.  In the traditional language of Critical Path Method scheduling, it’s most simply described as a Late Dates schedule.  Backward planning is useful in several non-standard methodologies, including Critical Chain Project Management and the “Pull Planning” aspects of the Last Planner System.

The Mechanics of Backward Scheduling

When specified for the active project, this mode essentially does the following:

  1. Sets the default constraint type for all new tasks to As Late As Possible.
  2. Re-sets the constraint type for all existing Summary tasks to As Late As Possible.
  3. [Users choosing this mode in the middle of schedule development must manually re-set the constraint type for all existing non-Summary tasks to As Late As Possible.]
  4. Automatically sets “No Later Than” constraints when dates are manually entered into the Start or Finish fields of tasks.  [Such date entry in forward scheduling mode leads to “No Earlier Than” constraints, so users choosing this mode in the middle of schedule development should manually review, validate, and potentially re-set any previously-entered date constraints.]
  5. Performs the network scheduling calculations in reverse order, with the reflection point occurring at the project start rather than the project finish.  I.e. the Project Start Date (not the Finish, which is user-input) is determined by the logic.
  6. Sets the “Start” and “Finish” of automatically-scheduled tasks to their Late Dates rather than their Early Dates.  (This is the most important part.)
  7. Finally, the resource leveling engine resolves resource over-allocations by accelerating higher priority tasks from late dates rather than delaying lower priority tasks from early dates.  Thus, entries in the “leveling delay” field are negative.  This behavior creates a minor complication regarding use of Priority = 1000.  Just as in forward scheduling, a task with Priority=1000 is always exempted from any leveling action.  In backward scheduling, this means that Priority values of 1000 and 0 are essentially equivalent when considered in the leveling decisions.  The highest effective Priority for controlling leveling behavior then becomes 999, not 1000.

Logic relationships used in backward scheduling still have exactly the same meanings that they do in forward scheduling.  A Finish-to-Start relationship still means that the two tasks are logically connected such that the successor may not start before the predecessor finishes, and the rarely-applicable Start-to-Finish relationship still indicates that it is impossible for the successor to finish before the predecessor starts.  Some users seem to think that backward scheduling involves reversal of these two relationships in particular, but that’s not consistent with the rest of the backward scheduling mode.  Unfortunately, mixing of the two approaches seems to continue, though this typically amounts to invalid date manipulation in my view.

In normal (i.e. forward) scheduling, a task with an “As Late as Possible” constraint has the dubious distinction of corrupting its entire chain of successors – driving all of them to the critical path.  There are very few legitimate applications for this constraint.  In backward scheduling, the “As Soon as Possible” constraint plays a similar role, corrupting its chain of predecessors.  It needs to be avoided in backward scheduling.

When to Use Backward Scheduling

I’ve never used backward scheduling in a real project.  Others have recommended its use to determine the desired start date of a project when the desired completion date is already known.  It also seems consistent, when tasks are suitably buffered, with aspects of Critical Chain Project Management that require work to be scheduled as late as possible.

Ultimately, backward scheduling rests on the presumption that tasks can be accelerated (i.e. moved to the left on the bar chart) indefinitely as needed to meet the fixed end date for the project.  Thus, a task whose duration is extended can simply be re-scheduled to start sooner than previously planned.  And its predecessors can be similarly accelerated.  Similarly, a higher priority task can be started (and finished) earlier to avoid resource conflicts with a lower-priority task that demands the same resources.  The problem with this presumption is that time invariably marches forward, and as scheduled dates for incomplete work are overtaken by the vertical time-now line on the bar chart there is no chance for recovery.  Backward scheduling method seems pointless if the latest allowable Project Start Date has already been passed – e.g. the project is in progress.

Backward scheduling seems to be of primary value in determining the latest responsible date to start a project (or project segment) while still meeting the desired completion date.  After that, the project must be converted from backward-scheduled to forward-scheduled mode if it is to be used for updating and forecasting during project execution.  The original question – i.e. what is the latest responsible project start date? – is also easily answered by manipulating and examining the late dates of the forward scheduled project.  Thus, for a competent project scheduler, the use of backward scheduling seems largely to be an unproductive diversion.

Driving Logic Analysis

When the logic network is well constructed – and complicating factors like multiple calendars, (Early) constraints, and resource leveling are avoided – then the Critical Path may be reasonably identified by Total Slack = 0.  Other methods of driving logic analysis must be modified, however.

Under Backward Scheduling, any slack/float of a task exists on the side towards its predecessors, i.e. to its left on a bar chart.  A driving relationship exists when a successor prevents a predecessor from being scheduled any later than it is.  This means that there are Driving Successors and Driven Predecessors.  Consequently, the Longest Path in a backward scheduled project is the Driving (Successor) Path from the Project’s Start.

MSP includes two built-in methods for reviewing and analyzing driving logic: the Task Inspector and the Task Paths bar styles.  As I wrote in this article a few years ago, I’ve found these tools to be unreliable in complex real-world project schedules.   Under backward scheduling, they are essentially useless and/or misleading.

To start with, Task Inspector simply doesn’t work with backward scheduling.  Opening TI on a backward scheduled project yields the following message:  This project is set to Schedule from Finish.  We are unable to provide scheduling information.

Also under backward scheduling, the “Driving Predecessors” and “Driven Successors” bar styles are still derived from Early Dates, as they are in Forward Scheduling.  This makes them essentially useless for assessing the controlling logic of the displayed (Late Dates) schedule.  Consider the example below, where all four Task Path bar styles have been imposed, and Task 11 – A2 Structures – is selected.  (The automatic “Slack” bar style is also imposed, but it is invisible since Free Slack – formally defined by Early dates alone – is uniformly zero.) 

The selected task is in fact driving/controlling the displayed dates of both of its predecessors, but only one of them displays the correct bar style (the one that was the driving predecessor during the forward pass).  Of Task 11’s four successors, only the first (Task 13 – A2 Electrical) is directly driving/controlling Task 11’s schedule.  The tasks for two of the remaining three successor relationships are incorrectly highlighted, while the third (Task 14) is correctly highlighted only because it is driving/controlling Task 13 – a case of redundant logic.  (All four successors were driven successors during the forward pass.)  Thus in a backward scheduled project, the Task Path bar styles for Driving and Driven dependencies are meaningful (or “correct”) ONLY along the Longest/Critical path of the project, where Early dates and Late dates coincide.

BPC Logic Filter – my company’s Add-In for logic analysis of MSP schedules – identifies driving logic based on relationship free float, which we often call “relative float.”  In BPC Logic Filter, the Longest Path and near-longest paths of simple, backward-scheduled projects can be found using the Task Logic Tracer, starting from the project start milestone and using appropriate settings (i.e. driving relationships in successor direction).  As illustrated in the example project, this is fairly trivial since the results are 100% aligned with Total Slack. 

Other driving logic paths (not on the Critical Path) are not so trivial but are easily addressed using BPC Logic Filter, provided that the impact of multiple calendars is minimal.

Precision analysis of more complex, backward-scheduled projects would require some modest modifications to the algorithms.  If any BPC Logic Filter users see a need for such an improvement, please let me know in the comments, and I’ll pass it along.

BPC Logic Filter – Version 1.5 Improvements

The latest release of BPC Logic Filter – an Add-in for schedule logic analysis in Microsoft Project – includes direct implementation of the QuickTrace macros, faster logic-related formatting of Gantt chart bars, additional controls for logic-based schedule navigation, and overall snappier performance.

Introduction

My company started sharing BPC Logic Filter, our Add-in for Microsoft Project, in 2015.  Since then, we’ve made incremental improvements to the tool that get shared in real time.  Many of these improvements were prompted by informal user feedback, for which we are most grateful.  Version 1.5, released in January 2019, brings a few nice little goodies that we’ve been anticipating for a while….

QuickTrace

QuickTrace is a set of macros for simplified logic tracing and filtering in MSP.  I wrote the original macros for a blog entry several years ago, and subsequent high traffic on that entry implies that a fair number of MSP users are downloading and implementing the macros.  We’ve now partially integrated that code with the rest of the add-in, providing a new ribbon button and a dedicated form, and including QuickTrace in the daily logs.

Eventually, we may get rid of the two boxes for selecting custom fields, streamlining the form even more.

QuickTrace is fully aligned with MSP’s internal “Task Inspector” and the associated “Task Path” bar styles (in MSP 2013+).  Like the two native tools, QuickTrace relies on internal MSP calculations for identifying “driving” logic.  This makes it blazing fast compared to the rest of BPC Logic Filter.  Also like the two native tools, it incorrectly identifies driving logic paths in the presence of certain (fairly common) complicating factors.

We’ve included QuickTrace as a reasonable accessory.  It is particularly useful when there is a need to compare its results with those of the other logic Tracers in BPC Logic Filter.  (This is the chief argument for leaving the QuickTrace custom fields as user-selected, outside the Add-in’s normal routines for selecting and managing its use of custom fields.)

[Because it relies on recursion (a kind of repeated “cloning” of itself), QuickTrace is subject to memory-overload errors.  This restricts the maximum path length that can be evaluated before “crashing out.”  Based on limited testing, the memory-limited maximum path length (in number of tasks) varies by MSP version and execution environment, as summarized here (figures are approximate).

The two obvious conclusions from the table are: 1) MSP 2016 imposes a much larger memory burden than MSP 2010, especially in the nominally-internal vba environment.   2) Compared to the macro/vba, BPC Logic Filter’s implementation of Quicktrace is far less likely to run out of memory on a very large project.  This advantage is amplified in MSP 2016.  On the downside, the out-of-memory add-in will crash hard, taking your data with it, while the macro/vba solution tends to crash softly.

For the add-in, QuickTrace’s lowest path-length limit – at 7,740 tasks – corresponds to 30 years of 1-day tasks arranged finish-to-start.  It seems unlikely that this limit could be reached in a real-world project of at least moderate complexity.  Nevertheless, as always, save early and save often.]

Bar Formatting Improvements

The first major upgrade of the tool (v1.1) included the ability to add certain logic-related information to bars in a Gantt Chart, specifically by modifying bar shapes, colors, and text.  Such information would be particularly useful for displaying related tasks within the context of an unfiltered view of the overall project schedule (i.e. “In-Line Only”), though I’ve had the habit of re-coloring bars in virtually all analyses.

For several reasons, bar coloring can impose a substantial time penalty on the completion of a logic analysis in BPC Logic Filter, with the size of the penalty being proportional to the number of tasks ultimately displayed.  Recent releases of Microsoft Project (e.g. MSP 2013+) have increased the size of this penalty while also introducing some erroneous coloring results for in-progress tasks.  Consequently, coloring Gantt bars in very large projects typically has been something to avoid.

Accelerated Bar Coloring

The new “Accelerate Bar Coloring” option is implemented via a single checkbox in the Bar Preferences tab – accessed directly through the “Settings” button on the Ribbon or indirectly through the “Bar Chart Options” button on the control window for each Tracer.

This option introduces an alternate bar coloring process that:

  • Draws bars more quickly for large filter outputs, with the largest outputs seeing the greatest gain. For example, I have configured a Near-Longest-Path analysis of an 18,000-task schedule to include every task in the output filter.  Without bar coloring, the overall analysis takes just under two and a half minutes (145 seconds) on my laptop computer.  With Accelerated Bar Coloring, the overall analysis takes 13 seconds more (158 seconds).  With traditional bar coloring, the overall analysis takes in nearly 20 minutes more!
  • Overcomes issues of incorrect bar coloring for in-progress tasks (MSP2013+).
  • Constructs and manages up to 25 new bar styles for uniquely and accurately describing the output. In contrast to the other option, these bar styles can be readily modified and augmented by advanced users of MSP.

These improvements can make the coloring of Gantt bars no longer something to avoid for large project schedules.

The new option does come at a cost, however.  Specifically, it uses 4 more custom Flag fields (in addition to the 3 needed for generating filtered views).  Custom fields typically get used up during the execution of a project, and constraining the need for custom fields was one of our key priorities during the early development of BPC Logic Filter.  This new demand may force schedulers to be a bit more disciplined in allocating them.  The accelerated bar coloring process also has a more rigid requirement for Data Persistence.  If “Permanently save the data for further analysis/presentation” is NOT checked, then none of the important information will be shown.  (With both the acceleration and permanently-save options turned off, bars are correctly colored, but logic-related text is not shown.)  Finally, the additional overhead imposed by the setting can actually slow down the overall analysis and display of a smaller project schedule, so it is not always the fastest.

Link Options

All previous versions of BPC Logic Filter have automatically enforced the inclusion of end-connected link lines (relationship lines) in logic tracing results.  The new version leaves this selection to the user.

Logic-Jumping Through Hidden Tasks

As any user of MSP’s built-in “Go To” (F5) tool knows, a task must be visible in the existing view to be selected and activated.  In the past, this meant that the Logic Inspector Jump buttons – used for navigating through the schedule based on logic relationships alone – could be blocked if portions of the schedule were hidden (by filters or outlining).  In the last build of version 1.4, we introduced some features for automatically breaking through such blockages.

Version 1.5 refines and provides for user-control of the behavior.  First, it is now possible to fully navigate through any project schedule using the Jump buttons alone, without selecting or activating the tasks in the corresponding task table.  This is the behavior demonstrated by the first radio button in the new form below.

Alternately, the Logic Inspector can automatically select and activate the hidden task by opening a closed Outline (i.e. summary task) where necessary and by adding the task to a temporary filter.  (Two types of filter persistence are supported.)

The new form is presented on the first attempt to Jump to a hidden task.  The options on the left side of the form tell the software how to handle the specific hidden task.  The buttons on the right side tell the software how long to remember this selection.  You can always change this decision using the “Reset Filter” button in the Settings.

Streamlined Code and Improved Housekeeping

In addition to the improvements noted above, Version 1.5 incorporates substantial changes to the underlying code base, leading to faster and more efficient analyses.

As a minor note, there is another new user control provided in the General Settings dialog: the “Clear BPC Fields” button.  This allows the permanent removal of all BPC-related custom field names and associated data.

Resource Leveling Changes from MSP 2010 to MSP 2016 – Revisited

In a departure from an earlier study, the resource-leveled schedule generated using Microsoft Project (MSP) 2016 may sometimes be substantially shorter than the comparable schedule from MSP 2010.  The result suggests a more sophisticated leveling algorithm that, while sometimes generating shorter schedules, may increase the associated resource-related risks.

Several years ago I wrote an article examining some reported differences in resource leveling behavior between Microsoft Project (MSP) 2010 and 2013 versions.  In general, those observations implied that the newer software was generating longer schedules under default conditions.  (The observations were by others, since at the time I was only using MSP 2010.)  I concluded the article with a speculation that the leveling algorithm may have been adjusted to preserve the appearance of the pre-leveling “Critical Path,” but at the expense of a longer schedule.

A recent test case using MSP 2016 does nothing to confirm that speculation, and an opposite conclusion is implied.

Below is an idealized schedule for construction and commissioning of a small processing plant, including resource loading.  Only technologically-required logic is included, so that a) the resources are all severely overallocated, and b) the schedule is unrealistic.  The same schedule is shown in both MSP 2010 and MSP 2016 forms, with only cosmetic differences.  There is a Deadline of 25Feb’05 on the Substantial Completion task, and no explicit risk buffers are present.  [The MSP 2010 form was used to illustrate the resource-leveled critical path in a technical paper I presented at AACE International in 2017.] 

To resolve the resource over-allocations and generate a more realistic schedule, the resource leveler is applied in both MSP 2010 and MSP 2016 using simple leveling options with no task priorities defined.

As shown below, these options lead to completely different schedules in the two tools, with MSP 2016 generating a leveled schedule that is 10-days shorter than the MSP 2010 version.

Key observations:

  1. The MSP 2010 schedule failed to meet the Deadline, so more tasks are marked Critical due to zero-or-negative Total Slack. Six tasks including the two milestones have TS=-10d (i.e. the “most critical” as defined by Total Slack.)
  2. The MSP 2010 leveler did not impose any task splits, even though they were allowed.
  3. The MSP 2016 schedule meets the Deadline, so no negative slack is imposed. Seven tasks including the two milestones have TS=0 (the “most critical.”)
  4. The MSP 2016 leveler imposed a task split on one task (A3 Structures).

A close look at the Resource-leveled Critical and Near Critical paths – Using the Near Longest Path Filter in our BPC Logic Filter add-in – demonstrates that MSP 2016’s leveler creates a more condensed schedule.  Specifically:

  1. MSP 2010 generates a single continuous Resource-leveled Longest Path (BPC Relative Float = 0) comprised of eight tasks in sequence. The other 12 tasks possess 10 to 70 days of relative float.
  2. MSP 2016 generates a continuous Resource-leveled Longest Path of 13 tasks in sequence, with 2 additional tasks (and a split part of one of the original 13) in parallel branches.  The other 5 tasks possess from 20 to 60 days of relative float.  As a result, more of the work is both concurrent AND Critical. It turns out that the splitting of the A3 Structures task is not the key to the more condensed schedule in MSP 2016.  In fact, re-running the leveler while disallowing splits leads to a schedule that – with no splits and with a completely different sequential arrangement – finishes at the same time. The corresponding Resource-leveled Longest Path is comprised of only 8 tasks in sequence, with 1 additional, parallel/concurrent task.  This leveled schedule has fewer resource mobilizations and disruptions along the longest path while still finishing at the earliest leveled time; it appears to be lowest risk.

This example suggests that MSP 2016’s default resource leveling algorithm may be substantially more sophisticated than MSP 2010’s, and it promises – under the right circumstances – to offer shorter leveled schedules in the absence of explicit user-defined priorities.  The shorter schedules may also be accompanied by technical and resource risks associated with multiple, concurrent branches of the resource-critical-path.  Project managers using resource leveling are advised to consider and buffer these risks appropriately.

In contrast with this finding and in keeping with the prior version of this article, others have continued to observe consistently longer schedules being generated by MSP 2016 (compared to MSP 2010 and earlier), on some standardized schedule models.  These observations are noted in the comments.

What is the Longest Path in a Project Schedule?

In Project schedules, the Longest Path yields the Shortest Time.  Aside from the mental gymnastics needed to digest that phrase, the concept of Longest Path – especially as implemented in current software – has deviated enough from its origins that a different term may be needed.   

Critical Path as Longest Path

Authoritative definitions of the “Critical Path” in project schedules typically employ the words “longest path,” “longest chain,” or “longest sequence” of activities … (that determine the earliest completion date of the project.)  In other words, the path, chain, or sequence with the greatest measured length is the Critical Path.  As a rule, however, none of the associated documents are able to clearly define what constitutes the length of a logic path, nor how such length will be measured and compared in a modern project schedule.  Without a clear standard for measuring the length of something, explicitly defining the Critical Path in terms of the longest anything is just sloppy in my view.

The Original Path Length

Assessing path length used to be much easier.  In the early days of CPM (Critical Path Method) scheduling, any project schedule could be guaranteed to have ALL Finish-to-Start relationships, NO constraints, NO lags or leads, NO calendars, and only ONE Critical Path.  Under these conditions, the length of a logic path could be clearly defined (and measured) as the sum of the durations of its member activities.  Thus, the overall duration of a Project was equal to the “length” (i.e. duration) of its Critical Path, which itself was made up of the durations of its constituent activities.  That result is indicated in the figure below, where the 64-day project length is determined by the durations of the 5 (highlighted) activities on the Critical Path.  Adding up the activity durations along any other path in the schedule results in a corresponding path length that is less than 64-days – i.e. not the “longest” path. [The network diagram was taken from John W. Fondahl’s 1961 paper, “A Non-Computer Approach to the Critical Path Method for the Construction Industry,” which introduced what we now call the Precedence Diagramming Method.  Unfortunately, Microsoft Project (MSP) has an early limit on dates, so his presumed ~1961 dates could not be matched.]

Fortunately, in such simple projects, it’s never been necessary to aggregate and compare the lengths of every logic path to select the “longest path.”  The CPM backward pass calculations already identify that path by the activities with zero-Total Float/Slack, and successively “shorter” paths are identified by successively higher Total Float/Slack values.  This fact has been verified in countless student exercises involving simple project schedule networks, typically concluding with the axiom that “the Critical Path equals the longest path, which equals the path of zero-Total Float/Slack.”

Float/Slack and Path-Length Difficulties

In general, modern complex project schedules have, or can be expected to have, complicating factors that make Total Float/Slack unreliable as an indicator of the Critical Path – e.g. non-Finish-to-Start relationships, various early and late constraints, multiple calendars, and even resource leveling.  See this other article for details.  Therefore, as noted earlier, the axiomatic definition has been shortened to “the Critical Path equals the longest path.”

Unfortunately, finding the “longest path” by arithmetically summing the activity lengths (i.e. durations) along all possible logic paths and comparing the results – not easy to begin with – has gotten more difficult.  Lags, excess calendar non-working time, early constraints, and resource leveling delays all add to the true “length” of a logic path compared to the simple summation of activity durations.  On the other hand, leads (negative lags), excess calendar working-time, and the use of overlapping-activity relationships (e.g. SS/FF) reduce its length.  In addition, any hammocks, level-of-effort, and summary activities need to be excluded.  All such factors must be accounted for if the “longest path” is to be established by the implied method of measuring and comparing path lengths in the project schedule.  I don’t know of any mainstream project scheduling software that performs that kind of calculation.  Alternatively, Deep Schedule AnalysisTM using the proprietary HCP (Hidden Critical Path) Method – from HCP Project Management Consulting – appears to compute and compare the lengths of all logic paths in Primavera and MSP schedules.

Longest Path as Driving Path

Contrary to summing up and comparing logic path lengths, current notions of the “longest path” are based on an approach that does not involve path “length” at all.  As a key attribute, the longest path in a simple, un-progressed project schedule also happens to be the driving logic path from the start of the first project activity to the finish of the last project activity.  It is a “driving logic path” because each relationship in the path is “driving”, that is it prevents its successor from being scheduled any earlier than it is.  Driving relationships are typically identified during the forward-pass CPM calculations.  Subsequently, the driving path to the finish of the last activity can be identified by tracing driving logic backward from that activity, terminating the trace when no driving predecessors are found or the Data Date is reached.  The resulting driving path to project finish is also called the “longest path” even though its “length” has not been established.  This is the “Longest Path” technique that has been applied for nearly two decades by (Oracle) Primavara and adopted more recently in other project scheduling tools.

As of today, MSP continues to define Critical tasks on the basis of Total Slack, but it provides no explicit method for identifying the “Critical Path” using a “longest path” criterion.  How is the responsible MSP scheduler supposed to respond to a demand for the “critical path” when the longest path has been obscured?  Here are several options:

  1. Continue to make simple projects, avoiding all complicating factors like calendars (including resource calendars), early and late constraints, deadlines, and resource leveling. Then assume that “Total Slack = 0” correctly identifies the Critical Path.
  2. If you are using MSP version 2013 or later,
    • Ensure that your project is properly scheduled with logic open-ends only present at a single start and single finish task/milestone, then select the single finish task,
    • Try to use the “Task Path” bar highlighter to highlight the “Driving Predecessors” of your selected finish task.  In the example below, a Deadline (a non-mandatory late-finish constraint) has been applied to task Op12 in the 1961 example, and MSP has responded by applying the “Critical” flag (based on TS=0) to Op12 and its predecessors Op10 and Op2.  As a result, the Critical Path is obscured.  Applying the bar highlighter and selecting task Op18 (the project’s finish task) correctly identifies the driving path to project completion, i.e. the “longest path.”  (For clarity, I manually added the corresponding cell highlighting in the table; the bar highlighter doesn’t do that.)
    • If necessary, create and apply a corresponding filter for the highlighted bars. I’ve posted a set of macros to make and apply the filter automatically in this article.
  3. If you are using MSP version 2007 or later,
    • Ensure that your project is properly scheduled with logic open-ends only present at a single start and single finish task/milestone, then select the single finish task,
    • Try to use the Task Inspector to identify the driving predecessor of the selected task, then go to it and flag it as being part of the driving path. Repeat this until the entire driving path is marked.
    • If necessary, create and apply a filter and/or highlighting bar styles for the flagged tasks.
    • I’ve posted another set of macros to do all this (except bar highlighting) automatically in this other article.
  4. Note: The previous two approaches both rely on MSP’s StartDriver task object to identify driving relationships. As noted in this article, however, the resulting driving logic is not reliable in the presence of tasks with multiple predecessors, non-FS predecessors, or actual progress.
  5. Use BPC Logic Filter or some other appropriate add-in to identify the “longest path” in the schedule.

Whichever method or software is used, expressing the Longest Path using the Driving Path methodology has one key weakness: it has not been proved generally useful for analysis of near-critical paths.  While the Longest Path may be known, its actual length is not readily apparent.  More importantly, there is no basis for computing the lengths, and hence the relative criticality, of the 2nd, 3rd, and 4th etc. Longest Paths.  Consequently, Near-Critical paths continue to be identified based on Total Float/Slack, which is still unreliable, or – in P6 – based on unit-less “Float Paths” from multiple float path analysis.

“Longest Path” and Early Constraints

As noted several times here, the methods described for identifying the “longest path” are in fact describing the “driving path to the project finish.”  This distinction can raise confusion when an activity is delayed by an early constraint.  Consider the case below, where an activity on the longest path (Op13) has been delayed 2 days by an early start constraint.  Consequently, its sole predecessor relationship (from Op3) is no longer driving, and Op3 gains 2 days of Total Float/Slack.  As shown by MSP’s “Driving Predecessor” bar highlighter, the driving logic trace is terminated (going backwards) after reaching the constrained task.

Identical results are obtained from Primavera’s (P6) Longest Path algorithm.  This is neither surprising nor incorrect; the project’s completion is in fact driven by the external constraint on Op13, and its predecessor Op3 is quite properly excluded.

It’s clear therefore that the driving path to project completion and the longest path from the project start (or Data Date) to the project completion can differ when an early constraint is present.  P6’s “Longest Path” algorithm automatically defaults to the driving path, not the actual longest path, and to date there have been no built-in alternatives to that behavior.  As a result, some consultants suggest that P6 Longest Path analyses should be rejected when external constraints – even legitimate ones like arrival dates for Customer Furnished Equipment – are present.  (A P6 add-in, Schedule Analyzer Software, does claim to provide a true Longest Path representation in the presence of early constraints.)

BPC Logic Filter – Longest Path Filter

BPC Logic Filter is a schedule analysis add-in for MSP that my company developed for internal use.  The Longest Path Filter module is a pre-configured version of the software’s Task Logic Tracer.  The module is specifically configured to identify the project’s longest path (as driving path) through the following actions:

  1. Automatically find the last task (or tasks) in the project schedule.
    • Excluding tasks or milestones that have no logical predecessors. (E.g. completion milestones that are constrained to be scheduled at the end of the project but are not logically tied to the actual execution of the project. The resulting trace would be trivial.)
    • Excluding tasks or milestones that are specifically flagged to be ignored, e.g. (“hammocks”)
  2. Trace the driving logic backwards from the last task to the beginning of the project.
    • Driving logic is robustly identified by direct computation and examination of relative floats. (Driving relationships have zero relative float according to the successor calendar.)  The unreliable StartDriver task objects are ignored.
    • Neither completed nor in-progress tasks are excluded from the trace.
  3. Either apply a filter to show only the driving logic path, or color the bars to view the driving logic path together (in-line) with the non-driving tasks. The example below is identical to the previous one, but BPC Logic Filter formats the bar chart to ignore the impacts of the applied deadline.  The resulting in-line view is substantially identical to the bar chart of the original, unconstrained project schedule. 

BPC Logic Filter and the (True) Longest Path

As noted earlier, an early constraint can truncate the driving path to project completion.  In that case, it is debatable in my view whether the addition of non-driving, float-possessing activities into the “longest path” makes that term itself more or less useful with respect to the typical uses of the “Critical Path” in managing and controlling project performance.  Nevertheless, such an addition is easily allowed in BPC Logic Filter by checking a box.  The bar chart below shows the results of the Longest Path Filter on the early-constrained example schedule, as set up according to the driving-path (Primavera) standard.  Results are identical to those of the built-in “Driving Predecessors” highlighter in MSP (above) and of P6.

The next chart shows the complete “longest path” for the project, including the non-driving Op3 activity.

The second chart is different because the check box for “Override if successor task is delayed by constraint” has been checked in the analysis parameters form.  Checking the box causes the non-driving predecessor with the least relative float to be treated as driving, and therefore included in the Longest Path, in the event of a constraint-caused delay.

For a quick illustration, see Video – Find the Longest Path in Microsoft Project Using BPC Logic Filter.

BPC Logic Filter and Near Longest Paths

As noted earlier, the normal methods for identifying the “longest path” (i.e. the driving path) in a project schedule have not been generally adopted for analyzing near-longest paths.  P6 offers multiple float path analysis, which I wrote about here.  In addition,  Schedule Analyzer (the P6 add-in mentioned earlier) computes what it calls the “Longest Path Value” for each activity in the schedule – this is the number of days an activity is away from being on the Longest Path (i.e. the driving path to project completion.)   In the absence of demonstrated user demand, however, MSP seems unlikely to gain much beyond the Task Path bar highlighters.

BPC Logic Filter routinely computes and aggregates relative float to identify driving and near-driving logic paths in MSP project schedules.  In this context, “near-driving” is quantified in terms of path relative float, i.e. days away from driving a particular end task (or days away from being driven by a particular start task.)  Its “Longest Path” and “Near Longest Path” analyses are special cases where the automatically-selected end task is the last task in the project.  For the Near Longest Path Filter, tasks can be shown in-line (with bar coloring) or grouped and sorted based on path relative float.  The “override if successor is delayed by constraint” setting has no effect when the Near Longest Path Filter is generated.  In that case, the non-driving task will be displayed according to its actual relative float.  For example Op3 is shown below with a relative float of 2 days (its true value), not 0 days as shown on the earlier Longest Path Filter view.

Recap

  1. In the development of the Critical Path Method, the “longest path” originated as one of several defining characteristics of the “Critical Path” in simple project schedules. Specifically, the “Critical Path” included the sequence of activities with the highest aggregated duration – i.e. the “longest path”.  Actual computation and comparison of path lengths was not necessary since relative path lengths could be inferred directly from Total Float – a much easier calculation.
  2. Complicating factors in modern project schedule networks tend to confuse the interpretation of Total Float, such that it is no longer a reliable surrogate for path length. As a result, the most recent, authoritative definitions of the Critical Path typically omit references to float while retaining references to “longest path” and, typically, logical control of the project completion date.  [Notably, the measurement and comparison of aggregated path durations (path lengths) has not been an explicit feature of any mainstream project scheduling tool, so the “longest-path” part of the definition cannot be definitively tested in general practice.]
  3. Notions of “longest-path” among current schedule practitioners are heavily influenced by the deceptively-named “Longest Path” feature in Oracle/Primavera’s P6 software. Perversely, that feature DOES NOT aggregate activity durations along any logic paths.  Rather, it identifies the driving/controlling logic path to the project’s finish.
  4. The “Longest Path” in P6 (i.e. the Driving Path to Project Completion) and the “longest path” (i.e. the logic path with highest aggregated duration) are NOT equivalent, particularly when the “Longest Path” is constrained by an early date constraint. There is at least one P6 add-in claiming to identify the true “longest path” (and near-“longest paths”) in this case.
  5. Microsoft Project provides several inefficient methods to identify the Driving Path to Project Completion in simple projects, but these methods are not reliable in the presence of non- Finish-to-Start relationships. There are no native MSP methods for identifying near-driving tasks nor the true “longest path” in the presence of early date constraints.  BPC Logic Filter is an MSP add-in that automatically fills these gaps.
  6. As conceived, the “longest path” criterion implied the transparent calculation and comparison of aggregated activity durations along each logic path in a project schedule. As for Total Float, however, such calculations in complex schedules have been obfuscated by complications like non- Finish-to-Start relationships, lags, and multiple calendars.  Since such obfuscation makes path lengths essentially un-testable, it appears that future Critical Path definitions should omit the “longest path” criterion in favor of a simple “driving path to project completion.”

Longest Paths in Backward Scheduled Projects (MSP) [Jan’19 Edit]

As pointed out in this recent article, the Longest Path in a backward scheduled project is essentially the “driven path from the project start,” not the “driving path to project completion.”

For more information, see the following links:

Article – Tracing Near Longest Paths with BPC Logic Filter

Video – Analyze the Near-Longest Paths in Microsoft Project using BPC Logic Filter

 

Avoid Out-of-Sequence Progress in Microsoft Project 2010-2016

Recording Actual dates that violate existing schedule logic can cause conflicts in Microsoft Project’s internal schedule calculations. The resulting Total Slack values and Critical task flags can be incorrect and misleading.  These issues are aggravated by recent (e.g. MSP 2016) versions of the software, and users are advised to minimize out-of-sequence progress.

Recording of actual progress in a logic-driven project schedule can be problematic.  As the “Actual” dates override or otherwise constrain the computed dates, the customary definitions of Float or Slack – and their resulting impacts on the “Critical” task flag in Microsoft Project (MSP) – no longer apply.  While I hope to undertake a general review of progress updating issues in a future article, this one has a special focus on out-of-sequence progress for two primary reasons:

  1. In all modern versions of Microsoft Project (e.g. ~MSP 2007+), the Total Slack values of “Critical” tasks with out-of-sequence successors can be altered unexpectedly.
  2. In MSP 2016 (and possibly beginning with MSP 2013), the Total Slack values of ALL tasks (not just “Critical” tasks) with out-of-sequence progress among their successors can be altered unexpectedly. As a result, many tasks can be shown incorrectly as “Critical” in MSP 2016 when they are not “Critical” in earlier versions.

What is Out-of-Sequence Progress

Out-of-sequence progress exists when actual progress is recorded (via, e.g. Actual Start, Actual Duration, Actual Work, %Complete, etc.) at times when the logical constraints of the schedule would normally preclude it.  For example:

  • An Actual Start is recorded for a task (the out-of-sequence, or OOS, task) whose Finish-to-Start predecessor has not finished. I.e. the Actual Start precedes the Early Start;
  • An Actual Start is recorded for an OOS task whose Start-to-Start predecessor has not started. Again, the Actual Start precedes the Early Start;
  • An Actual Finish is recorded for an OOS task whose Finish-to-Finish predecessor has not finished. Here the Actual Finish precedes the Early Finish.

In all cases there is a presumption that the recorded actual progress is more correct than the (theoretical) schedule model, so Early and Late dates are routinely overwritten by Actual dates during the schedule calculations.  When the actual progress occurs out of sequence, however, computing the Late dates (and slack values) of incomplete predecessors (during the “Backward Pass” calculations) is complicated by logical conflicts.  The software typically resolves these conflicts in a way that satisfies the needs of most users.

Completed, Out-of-Sequence Tasks

The issues discussed here are of primary concern in those cases where a task has started out of sequence and a) it remains incomplete; and b) the violated predecessor relationships remain unsatisfied (e.g. the FS predecessor remains incomplete.)  If either the OOS task or its unfinished predecessor task become complete, then they are treated like other completed tasks in Microsoft Project.  That is, they can influence the Early dates of their successors but have no impact on the Late dates of their predecessors.  As a result of this latter condition, an incomplete task whose sole successor has been completed out of sequence becomes effectively open-ended, i.e. without successors.  Under default conditions (i.e. “calculate multiple critical paths” NOT checked), the task’s Late Finish is set equal to the project’s Early Finish Date, and a high value of Total Slack is computed.

Obviously, this can have a major impact on the apparent Critical Path of a project.  In the example below, tasks CP2 and SP2 have both been completed out-of-sequence, and at a duration of only 20% of their baseline durations.  The overall project has been shortened, but the Critical Path has been truncated at CP3.  CP1 is no longer “Critical” because, in effect, it no longer has any successors.  It appears necessary to add a new FS relationship from CP1 to CP3 (and equivalently between SP1 and SP3) to re-establish the logic chain that has been broken by the completed, out-of-sequence tasks.

In Oracle Primavera P6, by contrast, the Retained Logic schedule setting automatically adjusts for activities completed out of sequence.  Thus, the need to finish CP1 before proceeding with CP3 is already included.  The result is a (presumably more realistic) 2-day delay in completion compared to the MSP result.

In-Progress, Out-of-Sequence Tasks

Key issues arise when the out-of-sequence task and its predecessor are both incomplete.  Because this behavior is sometimes different for MSP 2016 than it is for MSP 2010, we’ll look at both versions for the remaining examples.

For exploring the behavior of in-progress, out-of-sequence tasks, we examine the simple project schedule below.  The schedule is comprised of a single start milestone, a single finish milestone, a “Critical Path” string of four tasks, and a “Slack Path” string of four tasks.  The “Slack Path” is two days shorter than the “Critical Path,” with the last two tasks each having a shorter duration.  There is an unachievable Deadline applied to the finish milestone, and this creates negative Total Slack on the Critical Path.  Thus, the Critical Path tasks all have TS=-1d, and the Slack Path tasks have TS=1d.

With no progress, the project is scheduled identically in both versions of MSP.  Notably, P6 also starts with the same schedule dates.

Now let’s examine what happens when we record an out-of-sequence Actual Start on some future task.  In the example, the last task in each string (CP4 and SP4) is given an Actual Start that is one day earlier than its predecessors allow.  To keep things simple, no progress beyond the actual starts are recorded (i.e. %Complete = 0%.)  I’ve kept the “Split in-progress tasks” scheduling option checked (per default), so re-scheduling the project creates an initial split in tasks CP4 and SP4 and delays their remaining parts to satisfy the predecessor relationships.  As a result, all the tasks keep the same finish dates as before, and the project finishes on the same date as before, one day after the Deadline.

Although their start and finish dates have not changed, the logic-related information of the predecessors of the OOS tasks have been altered substantially.

  1. In both MSP 2010 and MSP 2016:
  • The Total Slack values of the Critical Path tasks that precede the OOS task (i.e. tasks CP1, CP2, and CP3) are all changed from TS=-1d to TS=0d.
  • This behavior is not justified: if the tasks are all executed according to the scheduled dates, the project will still finish one day late. The tasks should still have TS=-1d.
  • This is in fact a general result (see also Comment 1): (Presumably for MSP 2007 through MSP 365), any super-critical (TS < 0) task with an out-of-sequence, in-progress task in its successor chain will automatically have its Total Slack re-set to zero. Thus, out-of-sequence progress can cause a task with 60 days of negative Total Slack to appear much less Critical than it is.
  • This behavior can present a problem for project managers operating in a negative-slack (i.e. behind-schedule) regime, where schedule-recovery efforts are prioritized based on Total Slack values. Entering a single OOS Actual Start value (whether correct or not), can substantially alter the overall schedule recovery picture.
  • It seems most MSP users pay no attention to Total Slack values beyond the application of the “Critical” flag, and the observed behavior doesn’t change that. Consequently, for most users up through MSP 2010, out-of-sequence progress appears to have no substantial impact on the “Critical Path.”
  1. In MSP 2016, in addition to the prior behavior:
    • In the example, the Total Slack values of the Slack Path tasks that precede the OOS task (i.e. tasks SP1, SP2, and SP3) are all changed from TS=1d to TS=0d.
    • This behavior is also not justified. The tasks could all be delayed one day from their scheduled dates without compromising the project’s completion Deadline.  The tasks should still have TS=1d.
    • This is also a general result (see also Comment 1): (presumably for MSP 365 and maybe MSP 2013), ANY task (Critical or non-Critical) with an out-of-sequence, in-progress task in its successor chain will automatically have its Total Slack re-set to zero. Consequently, it will automatically and unavoidably be flagged as a Critical task.
    • For general MSP users after MSP 2010, therefore, out-of-sequence progress can have a substantial, even major, impact. In particular, tasks that are actually far from the Critical Path may be incorrectly flagged as Critical.
  2. The results in Oracle P6, however, appear more realistic.  The Late dates and corresponding Float values are unchanged from the initial schedule.

Below I’ve shown another perhaps more realistic example of the same simple project.  There has been a simple progress update on the Status Date of 1Oct’18, four working days into the project.  As of that date (the first Monday in the project), tasks CP1 and SP1 are still in-progress and have fallen one day behind the original plan.  Their successors (CP2 and SP2) have been allowed to start early, however, with each recording one day of actual progress.

Similar logical results are observed.  Task CP1 – the Critical predecessor of the Critical OOS task CP2 – now has TS=0d instead of TS=-1d in both software versions, and its Critical flag remains unchanged.

In MSP 2016 only, task SP1 – the non-critical predecessor of the non-critical OOS task SP2 – now also has TS=0d and is flagged as Critical.  This is incorrect.

As before, however, the late dates and Float values in the P6 version of the schedule are aligned with expectations.

Out-of-Sequence Progress and Task Path Driving Predecessors in MSP 2016

The “Task Path” bar styles provide useful methods for identifying related tasks, including the Driving Predecessors path, for any selected task in MSP 2013+.  The Driving Predecessors Task Path is particularly useful for confirming the Critical Path of a project when Total Slack is complicated by other factors.  Unfortunately, the method is not successful when out-of-sequence progress is encountered.  As shown in the figure below – repeating the two previous examples in MSP 2016 – the Driving Predecessors Task Path (orange-colored bars) is terminated when an Actual Start is reached on the backward (right-to-left) pass.  Thus, driving Task Path functionality is not compatible with out-of-sequence progress.

[The Task Path functionality is equally incompatible with in-progress schedules that involve Finish-to-Finish relationships among overlapping tasks, even if none of the progress occurs out of sequence.  Any Actual Start value terminates the progression of the associated bar formatting flag.]

Out-of-Sequence Progress and BPC Logic Filter

The impacts of out-of-sequence progress on the Total Slack of some tasks are the result of specific decisions in MSP’s backward-pass algorithms for computing Late dates and Total Slack.  Obviously, the algorithm has been tweaked between MSP 2010 and MSP 2016 leading to the even more undesired results.

BPC Logic Filter – my company’s MSP add-in for logic analysis – generally ignores MSP’s Deadlines, Late dates, Actual dates, and Total Slack values.  Instead, it performs separate backward and forward traces to determine driving logic paths and relative float values.  The latter, like Free Float, can never be negative.  Thus, when BPC Logic Filter encounters out-of-sequence progress during a trace, zero relative float is applied, and a driving relationship is inferred.  As shown in the examples below, this approach results in the correct identification of driving and near-driving paths to project completion, even when out-of-sequence progress is encountered.  [In the bar charts, the path relative float is listed to the right of each bar.  A zero-value represents the driving path with the bar characteristically colored (maroon), positive values and associated bar colors indicate the number of days away from driving the project completion.  

BPC Logic Filter also includes a Project Logic Checker to identify logic issues in Microsoft Project tasks.  Like many such tools, it automatically flags OOS tasks, along with their immediate predecessors, for correction.

 

Out-of-Sequence Progress in the Real World

This examination was prompted by an associate who, after a recent “upgrade” from MSP 2007 to MSP 2016, encountered numerous unexplained changes in the “Critical Path” during project updating.  As it turned out, the updated schedule contained extensive out-of-sequence progress that explained the observed behavior.  The out-of-sequence progress was the result of a schedule model that was ultimately invalid – a poor representation of the work, either as planned or as actually executed.  As is often the case in construction, this was aggravated by the persistent executive schedule pressure that converts some technological restraints (e.g. don’t start interior finishes until the building roof and skin are closed up) from mandatory requirements into mere preferences.

A typical invalid schedule model involves the representation of multiple overlapping activities as an over-simplified Finish-to-Start string.  For example, the schedule below shows five sequentially-related, non-critical tasks, of roughly equivalent work content, that are scheduled to occur over a five-week period.  Although they are shown sequentially, it is in fact customary to execute these five tasks nearly concurrently, with each task commencing as soon as its predecessor’s progress allows – and thereafter suspending or pacing progress to match that of its predecessors.

[Some schedule purists would suggest that these tasks should be broken down into many small, repetitive work packages, all arranged with pure Finish-to-Start logic relationships.  The resulting schedule is extremely detailed and reflects a true logical plan for executing the work.  In my experience, however, such a detailed plan can often be riddled with preferential logic that is ultimately over-ruled by field decisions.  Out-of-sequence progress – in spades – is the inevitable result; the scheduling workload multiplies with no added value.

Another approach might involve five parallel tasks, each of five weeks duration, modeled with continuous relationships or at the very least with compound (joint SS + FF) relationships.  Unfortunately, neither relationship is supported by MSP.  The dummy-milestone approach that I use to mimic compound relationships in MSP seems fairly esoteric, and the common alternative – using solely SS or FF relationships – can be problematic.]

The scheduler here has chosen the most expedient route, a simplified Finish-to-Start string of five activities.  Four weekly updates of actual progress then lead to the progressed schedule shown at the bottom of the figure.  While its appearance is substantially changed compared to the original plan, the progressed schedule – in MSP 2010 – seems to correctly depict the status and slack of the multiple in-progress, out-of-sequence tasks.  Thus MSP 2010 seems largely indifferent to the consequences of invalid logic combined with out-of-sequence progress, as long as the affected tasks are non-critical.

As my associate discovered, however, MSP 2016 is far less tolerant of such practices.  When the progressed schedule is recalculated in MSP 2016, the in-progress predecessors of the in-progress, out-of-sequence tasks are shown as Critical (with TS=0).  This is incorrect, as the tasks could all slip by 15 days without delaying the project.

For comparison, here are the corresponding updates for the identical project schedule in Oracle P6 (R18.8.10).  The dates and Float values are identical to those for MSP 2010; they are correct for these non-critical tasks.  (Original and Actual Durations in P6 are handled differently than in MSP, so those are not comparable.)

Review and Recommendations

Out-of-sequence progress is an unwelcome but often unavoidable occurrence in projects with logic-driven schedules.  It happens when the actual project execution is allowed to deviate from the plan in a way that creates logical conflict in the automatic scheduling calculations.  It typically results from a combination of the following circumstances:

  1. The schedule plan includes logic relationships that are not technologically mandatory. I.e. there are a number of alternative methods available for sequencing a group of related activities, and only one (preferred) method is incorporated into the schedule.  In addition:
    • Procedural controls are inadequate to ensure that project execution conforms to the preferred logic sequence; or
    • Subsequent to initial schedule development, the preferred logic sequence is altered due to field conditions, resource limitations, or other latent factors.
  2. Subsequent to initial schedule development, technologically-mandatory logical constraints are allowed to be violated – typically under schedule performance pressure – and the resulting technical risks are accepted.
  3. The schedule is based on scope and logic definitions that are overly simplified compared to the actual or achievable plan of execution. E.g. simple Finish-to-Start relationships are used to represent overlapping, partly-concurrent activities.
  4. Subsequent to occurrence of any of the prior circumstances, the schedule logic is not revised appropriately.
  5. Schedule updates do not include regular review and correction of invalid logic in light of out-of-sequence progress.

In MSP, a task that is both started and completed out-of-sequence may cause the incomplete tasks in its predecessor and/or successor chains to become effectively open-ended, with consequent impacts on Early and Late dates, Total Slack, and Critical task definition.  Consequently, the updated schedule may be invalid.

A task that is started out-of-sequence but remains in progress may cause substantial alterations to the Late dates, Total Slack, and Critical definitions of the incomplete tasks in its predecessor chains.  In particular:

  1. (In all modern MSP versions) Total Slack of behind-schedule tasks will change from negative to zero and in some cases turn positive. [See also comment 1.] Although the Critical flag won’t always change, any identification of driving and driven logic paths that is based on negative Total Slack will be incorrect.
  2. (In recent versions – e.g. MSP 2016) Total Slack of non-Critical tasks will change from positive to zero (with some exceptions), and each task will be incorrectly marked as Critical. [See also comment 1.]  Thus, the “Critical Path” and any other Slack-based identification of driving or driven logic paths will be incorrect.

These are pretty major consequences, yet their persistence suggests that they reflect as-designed behavior, not bugs.  It might even be suggested that the most recent “improvements” are intended to highlight the out-of-sequence progress – for correction of the associated logic.

In MSP, the only reliable way to avoid the negative consequences of out-of-sequence progress, in my opinion, is to avoid and/or minimize its occurrence.  Fundamentally, this means:

  1. Ensure that project schedules are based on sound consideration of the scope and logic of project execution.
  2. Ensure that procedural controls are put into place to a) validate, b) revise where necessary, and c) enforce the preferred sequence of activities.
  3. Where necessary, revise the schedule logic to reflect the actual/required sequence of execution.
  4. During regular progress updates, identify all out of sequence progress, and revise associated logic as appropriate to avoid the consequences noted above.

 

BPC Logic Filter in Microsoft Project 2013/2016

During its development, we targeted BPC Logic Filter – our Add-In for analyzing project schedules – for use with Microsoft Project (MSP) 2010.  After all, we developed the Add-In essentially for our own use, and MSP 2010 has been a regular tool for us (in Windows 7 boxes) since its inception.  Our most recent computer purchase brought with it necessary upgrades to 2016 versions of MS Office and MSP, all running the 64-bit flavor on a Windows 10 Workstation.

Now that I’ve had a chance to directly test BPC Logic Filter in an MSP 2016 environment, I must apologize to those users of our software who have suffered in silence with their MSP 2016 (and also MSP 2013) installations.  My initial testing experience with the filter functions was horribly slow, and I was finally able to repeat some crashing behavior – not encountered in MSP 2010 – that had been reported by a lone user.  No wonder the representative feedback from users on MSP 2013 and 2016 has been, love the Task Logic Inspector! (but silent on the other stuff).

With recent updates, we’ve managed to speed up the filter functions while completely eliminating the particular crashing issue.  As a result, with bar-coloring disabled, the new machine can complete a comprehensive Near-Longest Path Filter of a typical ~1000-task schedule in under 8 seconds.  This compares to an 11-second analysis of the same schedule on the old machine; I attribute the improvement primarily to the increased processing speed of the new machine.

Bar-coloring, however, remains sub optimal.  This is already time-consuming – manipulating Gantt bars and bar styles using essentially “foreground” processes.   As a result, the time to generate our comprehensive Near-Longest Path Filter on the old (MSP 2010) machine increases from 11 seconds to 33 seconds when bar-coloring with auto-ranging is selected.  Such an increase is justified by the improved communication that bar coloring allows.  Unfortunately, the time to perform the same task on the new (MSP 2016) machine increased from 8 seconds to 46 seconds, even after our optimizations and adjustments.  I would expect users with slower computers to have much worse experience.  It seems that manipulating graphic display objects involves substantially more processing power in MSP 2016 than in MSP 2010.  This is ironic in light of the general degradation in graphical output beginning with MSP 2013.  Unfortunately, we have not yet found a way around this problem.

Finally, there seems to be a bug in MSP 2016’s handling of the GanttBarFormat method when a) the method originates in a VSTO (Visual Studio Tools for Office) Add-In rather rather than in a native VBA (Visual Basic for Applications) procedure; and b) there is actual progress on the task.  (The GanttBarFormat method is used to apply format exceptions to a particular bar style of a particular task; like right-clicking on a bar and choosing “format bar”.)  Unfortunately, MSP 2016 ignores the selected bar style and applies the exception to the “Task Progress” bar if one exists.  This makes for some odd-looking outputs from our Add-In for schedules showing actual progress.  I’ll have to figure out a way to raise this issue and get it fixed.

Understand the Impact of Calendars on Schedule Slack Calculation in Microsoft Project

The most recent build of BPC Logic Filter includes improved calculation of relative floats for tasks whose Resource Calendars are substantially different from the effective Task and Project Calendars.  While reviewing those improvements, I compiled this summary of the three different Calendar types used in Microsoft Project (MSP) schedules – with particular attention to their use in logic-driven scheduling and Slack calculation.  The summary moves from the simplest (Project Calendar only) to the most complex (combined Task and Resource calendars) case.  The conclusions are based on my own (imperfect) testing in MSP Professional 2010 and 2016 environments, and I’d welcome any corrections.

Dale Howard of Sensei Project Solutions has provided an excellent general examination of Calendars in Microsoft Project.  It may prove useful to review his post before proceeding.

A. Project Calendar

  1. The Project Calendar is used to schedule all tasks in a project IN THE ABSENCE OF OTHER CALENDARS.  When present, Task Calendars supersede all of the Project Calendar’s functions, and Resource Calendars supersede some – but not all – of the Project Calendar’s functions.
  2. Without Task or Resource Calendars, each task’s early start date occurs when all logic constraints have been satisfied and the Project Calendar makes work time available.  The task’s early finish occurs when the assigned duration has been fully expended according to the Project calendar.
  3. Relationship lags are computed according to the Project Calendar.
  4. Start Slack, Finish Slack, and Total Slack are computed using the Project Calendar.
  5. The default calendar for ProjDateAdd, ProjDateSub, and ProjDateDiff functions is the Project Calendar.*
  6. Because only a single calendar is involved in all schedule calculations, Total Slack may be a reliable indicator of Critical Path within a single project schedule.
  7. If two projects with different project calendars are joined together with inter-project dependencies, then the interaction of working periods between linked tasks can cause Total Slack to vary along a single driving logic path.

B. Project Calendar PLUS Resource Calendars

  1. Each Resource possesses a unique Resource Calendar, which is comprised of a Base Calendar with specific modifications/exceptions.  For example, the Base Calendar for all resources in a particular country may include standard weekends and holidays for that country.  These are inherited by the Resource Calendar, while exceptions may be applied for specific Resource vacations.  By default, the Base Calendar is the Project Calendar at the time the resource is created.  An alternate Base Calendar can be assigned afterward.  The Resource Calendar has the same name as the Resource.
  2. When one or more resources are assigned to a task, the task is scheduled according to a) predecessor and successor logic, including lags; and b) the available working times in the Resource Calendars.  The task’s early start date occurs when all logic constraints have been satisfied and at least one assigned resource has available work-time.  The task’s early finish date occurs when the last resource assignment is completed.  For tasks that are not of type “Fixed Duration,” the Duration is the sum of all the intervals (from start to finish) during which at least one resource is working.  Thus, a task with multiple resources (each with a unique calendar) may have a Duration and Start/Finish dates that do not directly correspond to ANY single defined Calendar.  For Fixed-Duration tasks, the Duration is the difference between the early start and early finish as computed using the Project Calendar.  Thus, a Fixed-Duration task with 12-hours of work by a night-shift resource can have a Duration of Zero, based on the Project’s Standard calendar.  During the backward pass, Late dates are established similarly, based on (resource) working-time calendars.
  3. Relationship lags are computed using the Project Calendar.
  4. Start Slack, Finish Slack, and Total Slack are computed using the Project Calendar.
  5. The default calendar for ProjDateAdd, ProjDateSub, and ProjDateDiff functions used in custom Task fields remains the Project Calendar.  When used in custom Resource fields, the default calendar for these functions is the Resource’s Base Calendar, which is often the Project Calendar.*
  6. Since a resource calendar may delay a task from starting work during an available work period as defined in the Project Calendar, the task’s driving predecessor may possess slack.  Thus, Total Slack can vary along a single driving logic path.

C. Project Calendar PLUS Task Calendars (No Resource Calendars OR “Ignore Resource Calendars” Selected)

  1. A task calendar may be created and assigned to multiple tasks.  Each Task Calendar is a Base Calendar that may be created by copying and modifying an existing Base Calendar.  (Because it is a base calendar itself, a task calendar does not inherit information from other calendars.)
  2. Task Calendars may be used to refine schedule constraints based on the nature of the tasks being performed.  E.g. seasonal or environmental limitations.  Task Calendars may also be used to represent resource restrictions when no resources have been assigned (e.g. a year-end non-work period for certain tasks in a master/summary schedule.)  When “Ignore Resource Calendars” is checked, then assigned Resources will be compelled to work exactly according to the Task Calendar, possibly violating their own work time availability.
  3. Without effective Resource restrictions, the task’s early start date occurs when all logic constraints have been satisfied and the Task Calendar makes work time available.  The task’s early finish occurs when the assigned duration has been fully expended according to the Task Calendar.
  4. Relationship lags are computed according to the Task Calendar of the successor task, if it has one, or the Project Calendar.
  5. Start Slack, Finish Slack, and Total Slack for each task are computed using the Task Calendar, if it has one, or the Project Calendar.
  6. The default calendar for ProjDateAdd, ProjDateSub, and ProjDateDiff functions used in custom Task fields is the Task Calendar, if one exists, or the Project Calendar.*
  7. The interval between a driving predecessor and a driven successor may possess work time according to the predecessor’s calendar but not the successor’s.  The driving predecessor may possess slack.  Thus, Total Slack can vary along a single driving logic path.

D. Elapsed-Durations

  1. For most practical purposes, specifying a task duration using an “elapsed” unit (edays, for example), is essentially the same as: a) Applying a 24-hour task calendar with “ignore resource calendars” selected; AND b) Assigning a duration value that accounts for the project’s hours-per-day, hours-per-week, and days-per-month settings.  For example, 1 elapsed day is the same as 24 hours or 3 “days” (8-hours each) applied to a 24-hour working calendar.  (Since mixing duration “days” with 24-hour calendars routinely causes confusion, it is good practice to instead specify such durations in hours.)
  2. Any task with an elapsed duration will have the Task Calendar field disabled.  (A stored value may be visible, but it is inactive as long as the duration units are elapsed.)
  3. Since elapsed-duration tasks automatically ignore resource calendars, any assigned Resources will be compelled to work 100% without rest, possibly violating their own work time availability.  Consequently, it’s not a good idea to routinely apply elapsed durations together with resource loading.  Even machines need downtime for maintenance.
  4. Without effective Resource restrictions, the task’s early start date occurs when all logic constraints have been satisfied, period.  The task’s early finish occurs when the elapsed duration has been fully expended.
  5. Non-elapsed relationship lags are computed according to the Task Calendar of the successor task, if it has one, or the Project Calendar.
  6. Start Slack, Finish Slack, and Total Slack for each elapsed-duration task are computed on the basis of elapsed time.
  7. For tasks with elapsed durations, the default calendar for ProjDateAdd, ProjDateSub, and ProjDateDiff functions used in custom Task fields is the 24-Hour Calendar.*
  8. The interval between an elapsed-duration predecessor and its driven (non-elapsed) successor may possess non-working time according to the successor’s effective calendar (task, resource, or project).  The driving predecessor may possess slack.  Thus, Total Slack can vary along a single driving logic path.

E. Project Calendar PLUS Task Calendars PLUS Resource Calendars (NOT “Ignored”)

If the task’s “Ignore Resource Calendars” box is NOT checked, then:

  1. Each task is scheduled only during work time that is available in BOTH the Task Calendar and the applicable Resource Calendar for each assignment.
  2. The task’s early start date occurs when all logic constraints have been satisfied,  the Task Calendar makes work time available, AND at least one assigned resource has available work time.  The task’s early finish occurs when the last assignment is completed within the combined work time restrictions.
  3. Relationship lags are computed according to the Task Calendar of the successor task, if it has one, or the Project Calendar.
  4. Start Slack, Finish Slack, and Total Slack are computed using the Task Calendar, if any, or the Project Calendar.
  5. The default calendar for ProjDateAdd, ProjDateSub, and ProjDateDiff functions used in custom Task fields remains the Task Calendar, if one exists, or the Project Calendar.  When used in custom Resource fields, the default calendar for these functions remains the Resource’s Base Calendar.*
  6. As a result of either resource-delays or task calendar mismatches, Total Slack can vary along a single driving logic path.

*  Note: The comparable Project VBA functions (Application.) DateAdd, DateSubtract, and DateDifference always default to the Project Calendar of the ActiveProject.

F. Slack and Calendars Re-Cap

In general, the Project Calendar of a fully resource-loaded project schedule plays no direct role in role in the calculation of the Early and Late dates, but it plays a primary role in MSP’s subsequent calculation of Slack based on those dates.  Conversely, although resource calendars can fundamentally alter the logic-driven dates of a typical resource-loaded task, MSP ignores them in the Slack calculation.  As a consequence, both the calculation and interpretation of Total Slack in a resource-loaded schedule become greatly simplified, if sometimes misleading.

Alternately, whenever a task calendar is applied (with or without resource-loading), that same calendar is used to calculate the Dates AND the Slack.  Consequently, the calculation of Total Slack seems to be more correct and can be equally simple to calculate (using a Task- rather than Project-Calendar), but its interpretation can be confusing.

For example, the chart below illustrates two alternate methods for modeling a calendar-restricted Board-approval activity in a project schedule.  The Board meets on the third Wednesday of each month for, among other items, approving key project commitments.  If the project team fails to prepare the necessary documents in sufficient time for the meeting, then the approvals (and follow-on tasks) will be delayed by a month.  (This is exactly how project governance works in some organizations.)  For this example, the board-approval, preparation, and follow-up activities are not on the Critical Path for the project, finishing up about a month before the project’s finish milestone.

In the first case, the restraint on the Board Approval task is modeled by applying a Task Calendar with only the third Wednesday of each month as a working day.  In the second case, the restraint is modeled by loading a “Board Availability” resource whose Base Calendar is exactly the same as the Task Calendar applied above.  Early Dates and Late Dates for all tasks are identical for both cases, and the only difference is the Total Slack of the Board Approval task.  This value is computed as the difference between the task’s Late Finish (17Apr’19) and its Early Finish (20Mar’19).  When the restraint is applied using the Task Calendar, the Total Slack of 1 day reflects the fact that one Board Meeting/availability day exists between the two dates.  With the restraint applied using a resource calendar, the Project Calendar applies, and Total Slack of 20 days reflects the twenty weekdays between the two dates.

In either case, the example also illustrates the difficulty of identifying logic paths using Total Slack alone.

G. A Note on the Resource Availability Grid

The Resource Availability Grid (part of the Resource Information dialog window) is sometimes seen as an alternate/supplemental method for specifying resource working time.  Unlike the Resource Calendar, however, Resource Availability entries do not participate in the working-time definitions that drive the scheduling calculations.  Rather, they serve as a time-phased version of the Max Units property for identifying over-allocation of resources.  Once flagged, MSP can attempt to resolve these over-allocations through automatic resource-leveling.  This is distinct from logic-driven scheduling.

 

Extract the Logic Plan Inside Your Schedule – Project Virtual Conference 2018

In June 2018 I had the privilege of speaking at the Project Virtual Conference 2018.  The event was very well done and was supported by a number of key sponsors in the Microsoft Project consulting world.  (Surprisingly, Microsoft was not among them.)  I hope to have a chance to return in future years.  My session focused on using BPC Logic Filter to examine schedule plans.  The 55-minute session was recorded (link below).

There are a few lines I’d like to have back, especially the repeated reference to DCMA (the Defense Contract Management Agency) as the Defense Contract Management Association.  Maybe I conflated DCMA with the NDIA (the National Defense Industry Association) to create this new fiction….  Both have issued comprehensive guides related to project schedule quality, and the Planning and Scheduling Excellence Guide (PASEG) from NDIA is one of the better ones out there.

Don’t Confuse Critical Tasks with Critical Paths in Project Schedules

The “Critical” activity flags in modern project schedules often do not correctly identify the true Critical Paths.  Blind acceptance of such “Critical” flags to identify the Critical Path inhibits proper understanding, communication, and management of project schedule performance – and gives CPM a bad rap.

Basic CPM Concepts (in General):

The “Critical Path Method” (CPM) – a ~60-year-old algorithm of fairly straightforward arithmetic – lies at the core of most modern project scheduling tools, and most project managers worthy of the name have been exposed to at least the basic CPM concepts.  Any discussion of the Critical Path must address the underlying conceptual basis:

  1. A CPM project schedule is comprised of all the activities necessary to complete the project’s scope of work.
  2. Activity durations are estimated, and required/planned sequential restraints between activities are identified: e.g. Predecessor task “A” must finish before Successor task “B” can start, and Predecessor task “C” must finish before Successor task “D” can start.  The combination of activities and relationships forms a schedule logic network.  Below is a diagram of a simple schedule logic network, with activities as nodes (blocks) and relationships as arrows.
  3. Logic Relationships.  A logic relationship represents a simple (i.e. one-sided) schedule constraint that is imposed on the successor by the predecessor.  Thus, a finish-to-start (FS) relationship between activities A and B dictates only that the start of activity B may NOT occur before the finish of activity A.  (It does not REQUIRE that B start immediately after A finishes.)  Other relationship types – SS, FF, SF, which were added as part of the Precedence Diagramming Method (PDM) extension of traditional CPM – are similarly interpreted.  E.g. A–>(SS)–>B dictates only that the start of B may not occur before the start of A.  Activities with multiple predecessor relationships must be scheduled to satisfy ALL of them.
  4. Logic Paths. A continuous route through the activities and relationships of the network – connecting an earlier activity to a later one – is called a “logic path.”  Logic paths can be displayed – together or in isolation – to show the sequential plans for executing selected portions of the project.  The simple network shown has only two logic paths between the start and finish milestones: Path 1 = (StartProject) <<A><B>> (FinishProject); and Path 2 = (StartProject) <<C><D>> (FinishProject).  [Experimenting with some shorthand logic notation: “<” = logic connection to activity’s Start; “>” = logic connection to activity’s Finish.]
  5. Schedule Calculations. Schedule dates are calculated using three essential steps:
    • During the Forward Pass, the earliest possible start and finish dates of each activity are computed by considering the aggregated durations of its predecessor paths, beginning from the project start milestone and working forward in time.
    • Assuming an implicit requirement to finish the project as soon as possible, the early finish of the project completion milestone is adopted as its latest allowable finish date. This can be called the Finish Reflection.  (Most CPM summaries ignore this step.  I include it because it is the basis for important concepts and complications to be introduced later.)
    • During the Backward Pass, the latest allowable start and finish dates of each activity are computed by considering the aggregated durations of its successor paths, beginning from the project completion milestone and working backward in time.
  6. Driving and Non-Driving Logic. A logic relationship may be categorized as “Driving” or “Non-Driving” depending on its influence over the Early dates of the successor activity – as calculated during the Forward Pass.  A Driving relationship controls the Early start/finish of the successor; a Non-Driving relationship does not.  In other words, a “Driving” relationship prevents the successor activity from being scheduled any sooner than it is.  A logic path (or path segment) may be categorized as “Driving” (to its terminal activity) when all of its relationships are Driving.  [Such a path is sometimes called a “String.”]
  7. Total Float. In simplified terms, the difference between the early start/finish and late start/finish of each activity is termed the activity’s “Total Float” (or “Total Slack”).  A positive value denotes a finite range of time over which the activity may be allowed to slip without delaying “the project.”  A zero value (i.e. TF=0) indicates that the activity’s early dates and late dates are exactly equal, and any delay from the early dates may delay “the project.”  It is important to remember that Total Float/Slack is nominally computed as a property of each individual activity, not of a particular logic path nor of the project schedule as a whole.  [While computed individually for each activity, the float is not possessed solely by that activity and is in fact shared among all the activities within a driving logic path.  In the absence of certain complicating factors, it is common to refer to a shared float value as a property of that path.]
  8. Critical Path. A project’s Critical Path is the path (i.e. the unique sequence of logically-connected activities and relationships) that determines the earliest possible completion of “the project.”  I prefer to call this the “driving path to project completion.”  Other logic paths through the schedule are considered “Near-Critical Paths” if they are at risk of becoming the Critical Path – possibly extending the project – at some time during project execution.  In our simple project shown below, the Critical Path is Path 1, whose total duration of 4 weeks (20 days on a standard 5dx8h calendar) controls the Early Finish of the completion milestone.

    In unconstrained schedule models incorporating only a single calendar (and without other complicating factors), the Finish Reflection causes the activities on the Critical Path to have Late dates equal to their Early dates; i.e. Total Float = 0.  Consequently, any delay of a Critical-path activity cascades directly to delay of the project completion.  The Near-Critical Paths are then defined as those paths whose activities have Total Float more than zero but less than some threshold.  In traditional “Critical Path Management,” activities that are NOT on or near the Critical Path may be allowed to slip, while management attention and resources are devoted to protecting those activities that are on or near the Critical Path.  More importantly, acceleration of the project completion (or recovery from a prior delay) may only be accomplished by first addressing the activities and relationships on the Critical Path.

[Note: The definition of “Critical Path” has evolved with the introduction of new concepts and scheduling methods over the years.  The earliest definitions – based on robust schedule networks containing only finish-to-start relationships, with no constraints, no lags, and no calendars – were characterized by the following common elements:

  • It contained those activities that determined the overall duration of the project (i.e. the “driving path to project completion.”)
  • It contained those activities that, if allowed to slip, would extend the duration of the project (hence the word “Critical”.)
  • Its activities comprised the “longest path” through the schedule network. That is, the arithmetic sum of their durations was greater than the corresponding sum for any other path in the network.
  • After completion of the forward and backward passes, its activities could be readily identified by a shared Total Float value of zero.  Thus TF=0 became the primary criterion for identifying the Critical Path.

With the incorporation of non-FS relationships, early and late constraints, lags, and calendars in modern project scheduling software, these observations are no longer consistent with each other nor sometimes with a single logic path.  Some of these inconsistencies are addressed later in this article.  Only the first of these defining elements (“driving path to project completion”) has been generally retained in recent scheduling standards and guidance publications, though implied equivalence of the others continues to persist among some professionals.]

Software – the Critical Activities / Critical Tasks:

The basic element of modern project schedules is the activity or task.  In most scheduling tools, logic paths are not explicitly defined.  Nevertheless, the obvious importance of the Critical Path dictates that software packages attempt to identify it – indirectly– by marking activities that meet certain criteria with the “Critical” flag.  Activities with the “Critical” flag are called “Critical Activities” (or “Critical Tasks”) and are typically highlighted red in network and bar-chart graphics.

Applying Critical Flags using Default Total Float Criteria

The simplest criterion for flagging a task as “Critical” is TF=0.  This is the primary method that most new schedulers seem familiar with, and it is the default criterion for some software packages.  As noted earlier, this criterion is applicable to schedules with no constraints and only a single calendar.  In Microsoft Project (MSP) and Oracle Primavera P6 (P6), the default “Critical” flag criterion is TF<=0, and the threshold value of “0” can be adjusted.  The differences between these criteria and the simpler TF=0 criterion are justified by four primary concerns:

  1. Risk Management. Due to the inherent uncertainty of activity duration estimates, the Critical Path of a real-world project schedule – as ultimately executed – often includes an unpredictable mix of activities from the as-scheduled Critical Path and Near-Critical Paths.  In the absence of quantitative schedule risk assessment, it is reasonable to consider all such (potentially-critical-path) activities equally when evaluating project schedule risks.  This purpose is easily served by applying the “Critical” flag to all activities whose Total Float value is less than or equal to some near-critical threshold.
  2. Late Constraints. Overall project completion priorities (and contractual requirements) often lead to the imposition of Deadlines (in MSP), Late Finish Constraints (in MSP and P6), or Project Constraints (in P6).  Such constraints can override the Finish Reflection and cause the Late dates of some activities to be earlier or later than they would be in the absence of the constraints.  As a result, Total Float can vary among the activities on the driving path to project completion.   In a project with multiple constrained milestones, the driving path to only one of them (the most “urgent”) can be expected to have a constant total float value (i.e. the Lowest Total Float.)  Due to intersecting logic paths, Total Float can vary along the driving paths to other constrained milestones.   Applying the “Critical” flag to activities with Total Float less than or equal to the project’s Lowest Total Float marks those activities that are on the driving path to the most urgent constrained milestone in the project.  If a Project Constraint (in P6 only) is applied, the Lowest Total Float value may be greater than zero; without a more urgent constraint, the marked activities then denote the driving path to the final activity in the project.
  3. Negative Float. Late constraints can cause Late dates to precede Early dates for certain activities.  This results in negative values for Total Float/Slack (i.e. TF<0).    In practically all cases, negative Total Float indicates that the activity cannot be scheduled in time to satisfy one or more of the Deadlines or Constraints (though which constraint is violated may not be clear); and some corrective action is necessary.  [*The concept of negative float – and the constraints that create it – were not included in the foundations of CPM and PDM.  Negative float is not universally accepted among scheduling professionals today, and not all scheduling software supports its calculation.]

    Applying the “Critical” flag to all activities with Total Float less than or equal to zero then marks all activities that:

      • Are on the driving path to an unconstrained project completion (i.e. TF=0, controlled by the project’s Finish Reflection); OR
      • Are on the driving path to a constrained project completion or intermediate milestone that is just barely met (i.e. TF=0, controlled by Deadline/Constraint); OR
      • Are on the driving path to project completion where an explicit project completion milestone is violated (i.e. TF<0, controlled by project Deadline/Constraint); OR
      • Are on the driving path to some intermediate activity whose constraint is violated (i.e. TF<0, controlled by intermediate Deadline/Constraint); OR
      • Are on any number of non/near-driving paths to one or more constrained project completion or intermediate milestones, (i.e. TF<0). Though non-driving, these paths must still be shortened (in addition to shortening the driving and nearer-driving paths) to meet the milestones.

     

  4. Working-Time Calendar Effects. When activities with different Calendars are logically connected in a schedule network, the interval between the finish of a predecessor task and the start of its successor may sometimes contain working time for the predecessor but not for the successor.  If this occurs, then a driving logic relationship exists, but the predecessor still has room to slip without delaying any other tasks or the project (i.e. it possesses float.)  Thus, Total Float may vary along a single driving logic path, including the Critical Path.  The amount of this variation depends on the size of potential offsets between calendars: from a few hours (for shift calendar offsets) to a few days (for 5-day and 7-day weekly calendars offsets) to a few months (for seasonal-shutdown calendar offsets).

    Applying the “Critical” flag to all activities with Total Float less than or equal to the largest Calendar-related offset will mark all activities that:

    • Are on the driving path to project completion with TF<=0;
    • Are on the driving path to project completion but with TF>0 (and less than the specified offset);
    • Are NOT on the driving path to project completion but have TF less than the specified offset. These are False Positives.  For these activities, Total Float could be controlled either by the Finish Reflection (TF>=0) or by some other constraint.

Critical Flags and Critical Paths

Unfortunately, applying the “Critical” flag as noted for most of these considerations has one consistent result:  the continuous sequence of activities and relationships constituting a “Critical Path” often remains obscured.  It is disappointing that the majority of project schedulers – using MSP or P6 – continue to issue filtered lists of “Critical” activities as “The Critical Path.”  Much of the time – especially in MSP – they are not.  Even among expert schedulers, there is a persistent habit of declaring Total Float as the sole attribute that defines the Critical Path rather than as a conditional indicator of an activity’s presence on that path.

When an activity is automatically marked “Critical” based on Total Float/Slack, the primary conclusion to be drawn is simply, “this activity has Total Float/Slack that is at or below the threshold value.  That is, there is insufficient working time available between the Early- and Late- Start/Finish dates.”  If Total Float/Slack is less than zero, then one might also conclude, “this activity is scheduled too late to meet one or more of the project’s deadlines/constraints.”  [If automatic resource leveling has been applied, then even these simple conclusions are probably incorrect.]  These are important facts, but a useful management response still requires knowledge of the driving logic path(s) to the specific activities/milestones whose deadlines/constraints are violated – knowledge that Total Float/Slack and its associated “Critical” flag do not always provide.

Workarounds for Total Float Criteria

P6 provides several features, not available out-of-the-box in MSP, for correctly identifying the Critical Path when Total Float Criteria do not.  Specifically:

  1. For Risk Management. P6’s Multiple-Float Path analysis (MFP) allows the identification of successive driving and near-driving paths to specified project completion milestones.  Monitoring progress on these paths is worthwhile for risk management.  I’ve previously written about MFP analysis HERE.  P6 does not support using Float Paths (the output of MFP analysis) as an explicit criterion for the “Critical” activity flag.
  2. For Late Constraints and Negative Float. P6 allows a negative Critical float threshold.  It is possible to set this threshold low enough so that only the “path of lowest total float” is marked as critical.  In the absence of working time calendar effects, this criterion can be effective in identifying the (most) Critical Path.  Thus it is possible to correctly identify the project’s Critical Path when: a) there is only a single constraint on the project; AND b) that constraint coincides with the sole project completion milestone; AND c) that constraint is violated (creating negative float).
    • MSP does not allow a negative Critical float threshold, so correct identification of the Critical Path in a negative float scenario is not possible. All tasks with negative Total Slack are automatically and unavoidably flagged as “Critical.”
    • If the P6 schedule has a Project “Must Finish by” constraint, then the activities on the Critical Path may have positive Total Float. In that case, the lowest-float criterion may be applied (using a positive threshold) to correctly identify the Critical Path.
  3. For Working-Time Calendar Effects. Unlike other project scheduling software, P6 allows the “Critical” activity flag to be assigned on the basis of some criterion other than Total Float – called Longest Path.  The name is misleading, as the method is based on driving logic rather than activity durations.  Any activity that is found on the driving logic path to project completion is flagged as “Critical.”  (The algorithm tracks driving logic backward from the task(s) with the latest early finish in the project.)  The Longest Path criterion ignores the Total Float impacts of multiple calendars and constraints.  While it is effective in identifying the project’s Critical (logic) Path, Longest Path alone is not useful for identifying near-critical paths.  MFP analysis (noted above) is useful for this purpose.  “Longest Path Value ™,” a relative-float metric available in Schedule Analyzer Software (a P6 add-in) also helps to identify near-critical paths in these circumstances.  For a more detailed review, see What is the Longest Path in a Project Schedule?

MSP provides no out-of-the-box solutions to address these weaknesses in Critical Path identification.  Total Float/Slack remains the sole basis for applying the “Critical” flag, yet the impacts of constraints, deadlines, and calendars remain unaddressed.  In MSP 2013 and later versions, the Task Path function does provide a basis for graphically identifying the driving path to a selected completion activity, and this is helpful.  Nevertheless, a logic tracing add-in (like the BPC Logic Filter program that I helped to develop) is necessary to correctly identify the controlling schedule logic – including the true Critical Path – in a complex MSP schedule.

Definitions and Recommended Practices

Defense Contract Management Agency (DCMA – 2009)

DCMA’s in-house training course, Integrated Master Plan/Integrated Master Schedule Basic Analysis (Rev 21Nov09) is the source of the “14-Point Assessment” that – because its explicit “trigger” values are easily converted to Pass/Fail thresholds and red/yellow/green dashboards – is seen as a de-facto industry standard for schedule health assessment.  The course materials contain the following definitions:

(Slide 28) “Critical Path ~ Sequence of discrete work packages that has the longest total duration through an end point.
~ has the least amount of total float
~ cannot be delayed without delaying the completion date of the contract (assuming zero float).”
(Slide 98) “Critical Path – Definition: a sequence of discrete tasks/activities in the network that has the longest total duration through the contract with the least amount of float.
~ A contract’s critical path is made up of those tasks in which a delay of one day on any task along the critical path will cause the project end date to be delayed one day (assuming zero float).
(Slide 99) “The critical path is ‘broken’ whenever there is not a sequence of connected critical path tasks that goes from the first task of the schedule until the last task.  A broken Critical Path is indicative of a defective schedule.” 

These definitions are mostly (though not entirely) consistent with each other.  They do share a common emphasis on the … “Longest”… “Sequence” … with “lowest total float” AND day-for-day cascading of delay from any critical-path task directly to the project’s completion.  Obviously, the reliance on Total Float makes them incompatible with any project schedule that incorporates multiple calendars, late constraints, or resource leveling.

(Slide 97) “Critical Task:  Some tasks possess no float…they are known as critical tasks.
~Any delay to a critical task on the critical path will cause a delay to the project’s end date.”

Unlike most of the later definitions, DCMA’s appears to contemplate the existence of Critical Tasks that are NOT on the Critical Path.  Obviously, the expectation that such Critical Tasks possess “no float” is not compatible with negative-float regimes.

AACE International (2010 & 2018)

AACE International (formerly the Association for the Advancement of Cost Engineering) maintains and regularly updates its Recommended Practice No. 10S-90: Cost Engineering Terminology.  The most recent issue of RP 10S-90 (June 2018) includes the following definitions:

“CRITICAL PATH – The longest continuous chain of activities (may be more than one path) which establishes the minimum overall project duration. A slippage or delay in completion of any activity by one time period will extend final completion  correspondingly. The critical path by definition has no “float.” See also: LONGEST PATH (LP). (June 2007)”

CRITICAL ACTIVITY – An activity on the project’s critical path. A delay to a critical activity causes a corresponding delay in the completion of the project. Although some activities are “critical,” in the dictionary sense, without being on the critical path, this meaning is seldom used in the project context. (June 2007)”

Unfortunately, these definitions fall apart in the presence of multiple calendars, multiple late constraints, or negative total float – when the second and third clauses in both definitions no longer agree with the first.  They appear distinctly out of sync with modern project scheduling practices, and (according to AACE International’s Planning and Scheduling Subcommittee Chair) an update is pending.

AACE International’s RP No. 49R-06, Identifying the Critical Path (last revised in March 2010) instead defines the Critical Path as

the longest logical path through the CPM network and consists of those activities that determine the shortest time for project completion.  Activities within this [group (sic)] or list form a series (or sequence) of logically connected activities that is called the critical path.” 

Aside from the apparently inadvertent omission of a word, I don’t have any problem with this definition.  It is certainly better, in my opinion, than the first.

RP 49R-06 notes the existence of “several accepted methods for determining the critical path” and goes on to describe the four “most frequently used” methods:

  1. Lowest Total Float. This is as I described under Workarounds for Total Float Criteria, above.  Although this method is listed first, the RP spends four pages detailing the issues that make Total Float unreliable as a CP indicator.  As long as the CP is to be defined only with respect to the most urgent constraint in the schedule (including the Finish Reflection) – and there are no Calendar issues –  then this method provides a useful result.
  2. Negative Total Float.  In apparent acquiescence to the limitations of MSP, the RP describes this method by first abandoning the fundamental definition of the Critical Path as a specific logic path.  It then allows the “Critical” classification for any activity that must be accelerated in order to meet an applied deadline or constraint.  Ultimately, the RP attempts to justify this method based solely on certain legal/contractual considerations of concurrent delay.  It is NOT useful for those whose primary interest is timely completion of the project, or a particular part of the project, using Critical Path Management principles.
  3. Longest Path.  This “driving path to project completion” algorithm, as I described above in Workarounds for Total Float Criteria, has been implemented in versions of (Oracle) Primavera software since P3 (2.0b).  It is the preferred method for P6 schedules with constraints and/or multiple activity calendars.  A similar algorithm is included in BPC Logic Filter, our Add-In for Microsoft Project.  While the method is nominally aimed at finding the driving path(s) to the last activity(ies) in the schedule, it can be combined with other techniques (namely a super-long trailing dummy activity) to derive the driving path to any specific activity, e.g. a specific “substantial completion” or “sectional-completion” milestone.
  4. “Longest Path Value.”  This is an expanded method for identifying the driving and near-driving paths to project completion.  The method works by adding up relationship floats leading to a specific substantial completion milestone.  If the aggregate value of these floats along a specific logic path (i.e. “Longest Path Value”) is zero, then that path is identified as the Critical Path.  While the RP suggests that this method can be performed manually (presumably by “click-tracing” through the network of a P6 schedule), manual implementation in complex schedules is tedious and error prone.  As implemented in Schedule Analyzer Software, this method is essentially an improved version of  P6’s Longest Path method (except that the Add-in cannot change the “Critical” flag for activities.)  It is a preferred method in P6 for those possessing the Schedule Analyzer Software.  BPC Logic Filter performs similar analyses – using “Path Relative Float” instead of “Longest Path Value” – for MSP schedules.

While not listed among the “most frequently used” methods, P6’s MFP analysis option is briefly addressed by the RP in the context of identifying near-critical paths.  BPC Logic Filter performs similar analyses for MSP schedules.

None of the four methods described are useful for identifying the Resource Critical Path (or Resource-Constrained Critical Path) of a leveled schedule.

Project Management Institute (PMI-2011)

PMI’s Practice Standard for Scheduling (Second Edition, 2011) explicitly defines the Critical Path as

“Generally, but not always, the sequence of schedule activities determining the duration of the project.  Generally, it is the longest path through the project.  However, a critical path can end, as an example, on a schedule milestone that is in the middle of the schedule model and that has a finish-no-later-than imposed date schedule constraint.” 

Unlike the RP (49R-06) from AACE International, PMI’s Practice Standard provides no meaningful method for quantitatively identifying the activities of the Critical Path (or any logic paths) in a particular schedule model.  In fact, in its description of the Precedence Diagram Method (PDM – the modern version of CPM used by most modern scheduling software) the Practice Standard acknowledges the complicating factors of constraints and multiple calendars but notes that “today’s computerized scheduling applications complete the additional calculations without problems.”  Then it concludes, “In most projects the critical path is no longer a zero float path, as it was in early CPM.”  The Practice Standard goes on to scrupulously avoid any explicit link between Total Float and the Critical Path.  The impact of all this is to just take the software’s word for what’s “Critical” and what isn’t.  That’s not particularly helpful.

Finally, educating senior stakeholders on the subtle difference between “schedule critical” and “critical” is always one of the first issues faced when implementing systematic project management in non-project focused organizations.  The Practice Standard’s several conflicting definitions of Critical Activities tend to confuse rather than clarify this distinction.

U.S. Government Accountability Office (GAO-2015)

The GAO’s Schedule Assessment Guide: Best Practices for Project Schedules (GAO-16-89G, 2015) has been taken to supersede the earlier DCMA internal guidance in many formal uses.  (Nevertheless, the GAO’s decision to discard any formal trigger/threshold values – a good decision in my view – means that the DCMA-based assessments and dashboards remain popular.)  The GAO document contains the following formal definitions:

“Critical path: The longest continuous sequence of activities in a schedule. Defines the program’s earliest completion date or minimum duration.” [With some minor reservations related to meaning of “longest,” I believe this is a good definition.]

“Critical activity: An activity on the critical path. When the network is free of date constraints, critical activities have zero float, and therefore any delay in the critical activity causes the same day-for-day amount of delay in the program forecast finish date.”   [Unfortunately, the caveats after the first clause are insufficient, ignoring the complicating effects of multiple calendars.]

For the most part – and despite the float-independent formal definition above – the Schedule Assessment Guide’s “Best Practices” tend to perpetuate continued reliance on Total Float as the sole indicator of the Critical Path.  In fact, “Best Practice 6: Confirming That the Critical Path Is Valid” does a good job of illustrating the complicating factors of late constraints and multiple calendars, but this review leads essentially to the differentiation of “Critical Path” (based on total float alone) from “longest path” (based on driving logic).  This is a direct contradiction of the formal definition above.  In general, the text appears to be written by a committee comprised of P6 users (with robust driving/Longest Path analysis tools) and MSP users (without such tools.)  Thus, for every “longest path is preferred,” there seems to be an equal and opposite, “the threshold for total float criticality may have to be raised.”  This is silly.

National Defense Industrial Association (NDIA-2016)

The NDIA’s Integrated Program Management Division has maintained a Planning & Scheduling Excellence Guide (PASEG), with Version 3.0 published in 2016.  The PASEG 3.0 includes the following key definitions:

“Critical Path: The longest sequence of tasks from Timenow until the program end. If a task on the critical path slips, the forecasted program end date should slip.” 

“Driving Path(s): The longest sequence of tasks from Timenow to an interim program milestone.  If a task on a Driving Path slips, the forecasted interim program milestone date should slip.”

The second clause of each definition – which presumes a single calendar – is included in the Schedule Analysis chapter but is excluded from the formal definition in Appendix A.  Timenow is effectively the Data Date / Status Date.  The PASEG does not define or mention critical task/activity as distinct from a “task on the critical path.”

The PASEG notes, “Some of the major schedule software tools have the ability to identify and display critical and driving paths. Additionally, there are many options available for add-in/bolt-on tools that work with the schedule software to assist in this analysis.”  [I suppose BPC Logic Filter would be one of the mentioned add-in tools for Microsoft Project.]

The PASEG also mentions some manual methods for identifying critical and driving paths, e.g.:

a. Imposing a temporary, super-aggressive late constraint and grouping/sorting the output (presumably by Total Float and early start.  Though not explicitly mentioned in the method description, Total Float is the key output affected by the imposed constraint.)  Obviously, this method isn’t reliable when more than one calendar is used.

b. Building a custom filter by manually “click-tracing” through driving logic and marking the activities.  This method is most reliable in P6, with some caveats.  It is reliable in MSP only under some fairly restrictive conditions.

In general, these methods are non-prescriptive, though the emphasis on driving logic paths (rather than Total Float) seems clear.

Guild of Project Controls (GPC, “The Guild” – 2018)

The Guild is a relatively young (~2013) international community of project controls practitioners – initially associated with the PlanningPlanet.com web site – whose founding members have assembled a Project Controls Compendium and Reference (GPCCaR).  The GPCCar takes the form (more or less) of an introductory training course on Project Controls, including Planning and Scheduling.  The GPCCaR includes no formal Glossary, Terminology, or Definitions section, so “Critical Path” and “Critical Path Activities” accumulate several slightly varying definitions in the applicable Modules (07-01, 07-7, and 07-8).  In general, “Zero Total Float” and “Critical Path” are used interchangeably, and the complications of multiple calendars and multiple constraints in P6 and MSP are ignored.  This is not a suitable reference for complex projects that are scheduled using these tools.

Recap

  1. A full understanding of driving and non-driving schedule logic paths for major schedule activities is useful for managing and communicating a project execution plan.
  2. The most important logic path in the project schedule is the “Critical Path,” i.e. the driving path to project completion.  Overall acceleration (or recovery) of a project is ONLY made possible by first shortening the Critical Path.  Acceleration of activities that are NOT on the Critical Path yields no corresponding project benefit to project completion.  Multiple Critical Paths may exist.
  3. Some traditional notions of Critical Path path behavior – e.g. Critical Path activities possess no float; slippage or acceleration of Critical Path activities always translates directly to project completion – are not reliable in modern project schedules.
  4. Total Float remains a valuable indicator of an activity’s scheduling flexibility with respect to completion constraints of the project.  An activity with TF=0 may not be allowed to slip if all project completion constraints are to be met.  Activities with TF<0 MUST be accelerated if all the constraints are to be met.
  5. Project scheduling software typically defines individual activities as “Critical” without fully accounting for common complicating factors like multiple constraints and calendars.  As a result, the collection of “Critical” tasks/activities in a complex project schedule often fails to identify a true Critical Path.
  6. A Critical task/activity is best defined (in my opinion) as EITHER:
    1. An activity that resides on the Critical Path; OR
    2. An activity whose delay will lead to unacceptable delay of the Project Completion; OR
    3. An activity whose delay will lead to unacceptable delay of some other constrained activity or milestone.
    4. In general, these conditions are mutually exclusive, and different activities within a single project schedule may satisfy one or more of them.
  7. Professional project managers and schedulers should be careful not to automatically characterize “Critical” tasks (i.e. those with low Total Float) as indicators of a project’s Critical Path when complicating factors are present.