This year, the PRICE cost research team is kicking off a major research study on electronics.  The field of electronics changes very rapidly, and we want to ensure our estimation methods are well suited for the latest technology.  While we constantly collect data and update relationships, this study will go above and beyond the norm.  We'll visit modern electronics facilities, interview experts, visit customers to discuss their electronics estimating challenges, and start a major data collection and analysis effort.  In the end, we plan to add many new electronic classifications, reexamine our methods for quantifying complexity, and enhance our custom microcircuits guidance.

We recently toured a modern electronics manufacturing facility to get some hands-on experience.  We walked through the facility, going step-by-step through the manufacturing process while seeing it in action, which led to some interesting discussions.  We talked about a variety of topics, such as cost implications of different quality and testing levels, military vs. non-military electronics, and how they manufacture electronics for different operating environments (extreme temperatures, radiation, dust, etc).

These experiences should prove useful in our research.  Right now, we have many hypotheses for what drives the cost of electronics, such as the topics we discussed at the manufacturing facility.  This is especially true for what we believe has changed in recent history in the field of electronics.  As we collect data, we can test these hypotheses and validate our existing estimating methods and algorithms, or develop new ones.  Our meetings with customers ensure that our final product speaks their language and fully addresses their needs.  We’re just getting started – check back for more updates!

Introduction:

The previous blog covered getting started with the TruePlanning API using VBA. Now it is time to tackle collections. Collections in the TruePlanning API are simply objects that hold a list of objects where all the objects are of the same type.  For example, the Project object contains a collection of the Cost Objects that belong to the project.  In order to use the TruePlanning API, mastering collections is essential, but “mastering” is a bit strong a word given that they are easy to use.

By the end of this blog TruePlanning API users should be up and running with the many different collections that are found in the TruePlanning API.

Setup:

This blog will start where the first blog left and will be based on the Excel file that was created in the first blog.  Perform the following steps to get setup :

1. Open or create the Excel file from the first blog. You should see the following code:

2. Delete lines 9 through 15 in the above code (counting all line from the top). The code should now look like:

3. Create a TruePlanning project and name it “T1”.

4. Give the “T1” project the following PBS:

5. Calculate and save the “T1” project.

6. Make at least three copies of the “T1” via the Project Manager dialog in TruePlanning. This will ensure that the following code will be able to loop through more than one project.

7. Close the “T1” project.

Working with Collections:

As stated above, the collection objects in the TruePlanning API are really just lists of like-type objects such as Projects, Cost Objects, Activities, Resources, Worksheet Sets, Inputs, and Metrics.

The following is a list of the collection objects found in the TruePlanning API:

Notice that the names are all plural. The standard naming convention is that a collection is the plural form of the objects that make up the collection. So the Projects collection is made up of Project objects and the Cost Objects collection is made up of Cost Object objects.

There are really only two ways to work with collections: direct access, which means to get a specific element of the collection based on an ID or name, or to go through each element of the collection.  How you access the contents of a collection depends on the context of the code being written.

For example, a user might loop through all of the projects available in the Projects collection that is contained in the Session object in order to display a pick list for users to select a project. Once a user has selected a specific project, the code could then easily obtain the project by calling one of the direct access functions that are part of the Projects collection and providing the name of the selected project.

Both of these methods will be covered.

Rolling up our sleeves and getting to work:

The following steps will show how to work with the collections found in the TruePlanning API.

Iterating through each element of the collection:

The following code will show how to loop through each element of the collection. There are two ways to do this: indexing based on an incrementing variable, or if your language supports it, using a built in iteration looping mechanism such as a “for each” loop.

Manually iterating by index

This is the time honored, hairy-chested approach to iterating through a collection of elements and is based on the arrays found in most programming languages.  The core idea is that the total number of elements in an array is found and then a variable is incremented in a loop from a starting point (that will be discussed in a moment) up to the total number of elements (determining the total will also be discussed), and each element of the collection is accessed by using the incrementing variable as an index into the array.

To walk through the example of finding all of the projects available to a TruePlanning user, the following steps would be performed:

1. Define a variable to hold an incrementing value that will represent the current index into the collection.   For this example, it will be called “pCnt”

Dim pCnt as Long

2. Define a variable to hold the starting index value of the collection. For this example, it will be called “pStart”

Dim pStart as Long

3. Determine the starting index. Assuming the goal is to start at the beginning of the collection, there are only two options: zero (0) or one (1). The zero may seem odd to some people, but in some programming languages collections, or arrays, use zero as the first index value.  This is the case with collections in the TruePlanning API. Please note that this may or may not be the case with other arrays in the programming language you are working with (such as VB or VBA), but it IS always true with collections in the TruePlanning API without regard to the language being used. This means that our starting value for pStart is zero (0).

pStart = 0

4. Define a variable to hold the highest valid index value in the Projects collection, and then obtain that value from the targeted collection.  All TruePlanning collections have a method that returns the total number of elements in the collection called: Count. So for example,  if a user has access to 10 projects then the Count method  for the Projects collection will return a value of 10 when its Count method is called.

What needs to be noted is that because TruePlanning collections are zero index based the total count of elements will always return a value that is one greater than the highest valid index value in the collection. Using our 10 project example: while the Count method returns 10, the actual list of valid indexes is: 0,1,2,3,4,5,6,7,8,9.This means that if the Projects collection were to be accessed by index using the value returned by the Count method (10), an error would occur.

The result is that when determining the highest valid index value in a TruePlanning index, the value returned from the Count method needs to be subtracted by one because TruePlanning collections are zero index based.

Add the following code:

Dim pTot as Long


pTot = ses.Projects.Count - 1

5. Now that a start and end index have been obtained (assuming 10 projects, the start is 0 and the end is 9), a way to loop through those indexes needs to be employed. Most programming languages have some type of “for” loop that supports looping based on an incrementing variable. The exact formats will differ, but structurally they have the same components: a variable to be incremented, a maximum value for that variable, and some mechanism for defining the code that will be executed with each loop. In VBA the “For” loop does the job.  The variable to be incremented will be “pCnt”, the maximum value is stored in “pTot”. The code to be executed will be all code that is placed between the start of the “For” loop and the “Next” statement. 

Add the following code below the line ():

For pCnt = pStart to pTot

   Set proj = ses.Projects(pCnt)


   If (proj.Name = “T1”) Then

      MsgBox(“Found It!!!!”)

   End If

Next pCnt

6. The code between the “For” and the “Next” keywords is doing the work. Notice how the Projects collection is being indexed through the use of the current index count in parenthesis.  Also notice how the Project object is set equal to an element in the Projects collection through the use of the indexing. Don’t forget the “Set” keyword.  Once a Project object has been assigned to an object the methods on the Project object can be used. In the example the project name is being tested.

7. The following is a complete code listing:

Private Sub CommandButton1_Click()

   Dim app As TruePlanningApi.Application

   Set app = New TruePlanningApi.Application

  

   Dim ses As TruePlanningApi.Session

   Set ses = app.Login("(local)")

  

   Dim proj As TruePlanningApi.Project

  

   Dim pCnt As Long

   Dim pStart As Long

   Dim pTot As Long


   pTot = ses.Projects.Count – 1

  

   For pCnt = 0 To ses.Projects.Count - 1

      Set proj = ses.Projects(pCnt)

     

      If (proj.Name = "T1") Then

         MsgBox ("Found It!!!!!")

      End If

  

   Next pCnt


   ses.Logout

  

   Set proj = Nothing

   Set ses = Nothing

   Set app = Nothing


End Sub

Use built-in looping mechanism

The manual method for iterating over each element in a collection, as described above, provides developers with great control over how the elements of a collection are accessed. The elements could be accessed in reverse order, or the loop could be set at some arbitrary start point in the collection to eliminate searching the total set of elements.  With that control comes overhead. Variables need to be set up correctly, there is the potential to end up with an index value that is not valid and the developer needs to know if the collection is zero index based or one index based. 

Looping over a collection of elements is a very common need so many programming languages provide mechanisms that make this easier. These mechanisms will find the right start point and will continue to loop until the end of the collection, and then exit gracefully. They reduce the work for the developers and reduce the potential for error. Unless there is a specific need, using one of these mechanisms will usually save time, produce safer code and be easier for other developers to understand. 

As VBA is the language being used for this example, the mechanism to be used is the “For Each” loop and it does what is sounds like it will do: it will iterate over each element in a collection or array.  To use it a variable is needed to hold the currently selected element, so a variable of the type contained in the collection needs to be defined. The code executed by the “For Each” loop is bound by the “Next” keyword. All code between the start of the “For Each” loop and the “Next” keyword is executed with each iteration of the loop.

Once set up the “For Each” loop will iterate over each element in the targeted collection until it reaches the end or a special command is given to exit the loop early. You would use such a commend if you were looking for a specific element in the collection, and once you found it, did not need to continue looping through all of the elements in the collection.

To walk through the example of finding all of the projects available to a TruePlanning user, the following steps would be performed:

1. Create the variable that will hold the element items as they are sequentially accessed:

Dim curProj as TruePlanningApi.Project

2. Set up the “For Each” loop. Here the Session object ses contains the Projects collection so it is referenced:

For Each curProj in ses.Projects


Next

3. Now add some code to be executed with each loop:

For Each curProj in ses.Projects

   If(curProj.Name = “T1”) then

      MsgBox(“Found using for each!!!!!”)

   End if

Next

4. Escaping the loop! As mentioned above, it is sometimes desirable to exit the loop before the end of the collection has been reached.  In this example, after finding the project that we are looking for we can exit the loop. Different programming languages will have different mechanisms for achieving this. In VBA the keyword is “Exit For”.  Add the following code just before the “End If” line:

      Exit For

5. That’s it! Notice how much simpler the “For Each” loop was. Admittedly the code for the manual iteration could be streamlined to reduce its “bulk”, but the “For Each” is safer and easier.  The following is a complete code listing containing both approaches to iterating over the collection:

Private Sub CommandButton1_Click()

   Dim app As TruePlanningApi.Application

   Set app = New TruePlanningApi.Application

  

   Dim ses As TruePlanningApi.Session

   Set ses = app.Login("(local)")

  

   Dim proj As TruePlanningApi.Project

  

   Dim pCnt As Long

   Dim pStart As Long

   Dim pTot As Long


   pTot = ses.Projects.Count - 1

  

  

   For pCnt = 0 To ses.Projects.Count - 1

     

      Set proj = ses.Projects(pCnt)

     

      If (proj.Name = "T1") Then


         MsgBox ("Found It!!!!!")

  

      End If

  

   Next pCnt

  

   Dim curProj As TruePlanningApi.Project

  

   For Each curProj In ses.Projects

      If (curProj.Name = "T1") Then

         MsgBox ("Found using For Each!!!!!!!")

         Exit For

      End If

   Next curProj

   ses.Logout

  

   Set proj = Nothing

   Set ses = Nothing

   Set app = Nothing


End Sub

Direct Access of Collections

The example of supplying a user with a pick list of available projects, and then opening the selected project has been described above. The techniques for iterating over a collection would be used for the first part of this example. Each project found could be added to some type of control that would allow a user to pick the desired project.

Once the user has picked the project and wants the project opened, what options are there for getting the project from the collection of projects maintained by the Session object? The entire collection of projects could be iterated over until the desired project is found, but as the user has already identified the project, it would faster and easier to get the project directly from the collection using a direct access method. This can be a big performance savings when the collections are large.

Direct access methods allow users to get elements in a collection using some type of identifier. The two most common identifiers are a TruePlanning API specific ID variable, and the name of the element.  In the previous code examples, the name of the project being sought was “T1” so it is a simple matter to call on a method of the collection that returns the element that matches the identifying data.

Every TruePlanning API object that can be part of a TruePlanning API collection will have an “ID” attribute. “ID” attributes are a string representation of a Globally Unique ID (GUID) and are long and ugly, but helpful because they uniquely identify that specific TruePlanning API entity.   The “ID” values are set by the TruePlanning API so they should be treated as read only.

Coming back to the example of having users pick from a list of projects and then opening a project they selected, when the projects are iterated over to develop the pick list, their IDs could be obtained and stored so that when a user selects a project, the ID for the selected project is known and can be used in a direct access call against the Projects collection. One reason for using the “ID” attribute would be because it is a faster lookup than the name field.

One important consideration when directly accessing elements of TruePlanning API collections: if the data used to identify the element does not match any of the elements in the collection an error will be generated. This means when using any of the direct access methods on a collection the code must be robust enough to handle the possibility that the TruePlanning API will generate an error. In VBA this means using the “On Error” methods, but that is a bit beyond the scope of this blog.

Item by Name

As the name of the target project is known: “T1”. Getting the project with the name “T1” is straightforward.

1. Add the following code before the line “ses.Logout”:

Set proj = ses.Projects.ItemByName("T1")

2. Test what happens if the wrong data is provided to a direct access method. Change the project name to a project name that does not exist. The result will be a “Run-time error: Automation error”:

Set proj = ses.Projects.ItemByName("T1zzzzzz")

Item by ID

To provide an example of obtaining a collection element by ID, a bit of fancy code will be added. Above code was added to iterate over each project and test if the project matched a specific name.  Once the desired project has been found, the ID for that project can be obtained and then used later to get the specific element based on it’s ID.  Admittedly the example is a bit unnatural as the name of the project is known from the start, but that will be maintained to keep the example simple.

1. Declare a variable to hold the ID of the project once it is found. IDs are the string representation of a GUID.  Add the following code after the line “Dim pTot as Long”:

Dim projId as String

2. In the code that executed once a project with the right name is found add code to store the ID for the current project.  Add the highlighted line of code to the existing code block:

   For Each curProj In ses.Projects

      If (curProj.Name = "T1") Then

         MsgBox ("Found using For Each!!!!!!!")

         projId = curProj.ID

         Exit For

      End If

   Next curProj

3. Now that the ID has been obtained, call into the Projects collection to get the desired project. Add the following code below the code block in the previous step:

   Set proj = ses.Projects.ItemById(projId)

   MsgBox ("Current project is: " & proj.Name)

4. That’s It! The following is a complete code listing from all of the examples:

Private Sub CommandButton1_Click()

   Dim app As TruePlanningApi.Application

   Set app = New TruePlanningApi.Application

  

   Dim ses As TruePlanningApi.Session

   Set ses = app.Login("(local)")

  

   Dim proj As TruePlanningApi.Project

  

   Dim pCnt As Long

   Dim pStart As Long

   Dim pTot As Long

   Dim projId As String

  

   pTot = ses.Projects.Count - 1

  

   For pCnt = 0 To ses.Projects.Count - 1

     

      Set proj = ses.Projects(pCnt)

     

      If (proj.Name = "T1") Then


         MsgBox ("Found It!!!!!")

  

      End If

  

   Next pCnt

  

   Dim curProj As TruePlanningApi.Project

  

   For Each curProj In ses.Projects

      If (curProj.Name = "T1") Then

         MsgBox ("Found using For Each!!!!!!!")

         projId = curProj.ID

         Exit For

      End If

   Next curProj


   Set proj = ses.Projects.ItemById(projId)

   MsgBox ("Current project is: " & proj.Name)

  

  

   Set proj = ses.Projects.ItemByName("T1")

  

   ses.Logout

  

   Set proj = Nothing

   Set ses = Nothing

   Set app = Nothing


End Sub

Conclusion:

While the example used in here focused on the Project object, all of the collections in the TruePlanning API behave the same way. Some of the collections may have a few different methods such as adding new elements or deleting elements, but iterating over the collection or going after specific elements using direct access methods is the same.  The example code is a good start to helping users become proficient at leveraging the TruePlanning API.

In my previous blog, I introduced the relationship between three “breakdown structures” commonly used in project management, and how cost estimates are linked to them and aid in their usefulness.  In this blog, I’ll dig further into these relationships, and explain their impact on my Total Ownership Cost (TOC) solution in TruePlanning.

Let’s use an example of an aircraft being built for the Army.  In this hypothetical example, the prime contractor is Boeing, and they have different departments working on various parts of the aircraft.  Department 10 is responsible for the wings and the tail section of the aircraft.

Each slice in this direction represents an OBS “group”.  If a person in charge of Dept. 10 wanted to examine this cost estimate and only see what Dept. 10 is involved in, they can view that slice of the cube.   In this slice, you can see the WBS and CBS sections for the wing and the tail.  You can view budgets and cost estimates for wing and tail components, and look at specific wing and tail deliverables. 

The Dept. 10 user can get a complete view of the project from their perspective quickly and easily.  Other departments would have this same capability, and Boeing as a whole could look at a larger slice that contains Dept. 10 and more.  Any “group” could get a customized view.

You can also take a slice for any CBS element, such as Development Engineering.  All information about the WBS tasks requiring development engineering, and which OBS groups are doing the work are available in this view.  This is great for planning, budgeting and program execution and management, as you can examine any cost category (which often have separate budgets and dedicated managers) at the level of detail that’s right for you.

If you take a slice of the cube representing a specific WBS element, such as the Airframe, you can see how the funding is allotted for developing and producing the airframe, and which groups in your organization are doing the design and production work for each piece.  Also, early on you can do quick and easy analysis of alternatives by substituting a WBS element with an alternative solution.

Assessing Total Ownership Cost (TOC) is a requirement for all major programs in the US DoD.  This means each program cost estimate has a large set of stakeholders spanning multiple government and private organizations.  The ability to slice and dice a TOC estimate to best suit any stakeholder’s point of view is crucial for informed decision-making.  Using this structure ensures everyone has the same information, tailored to meet their needs.  As a cost researcher at PRICE, these ideas have a major impact on the design of our solutions.

Introduction:

The new TruePlanning COM Application Programming Interface (API) found in the 2012SR1 release of TruePlanning provides a powerful mechanism for leveraging the power of TruePlanning within custom solutions. Through the COM API TruePlanning projects can be created, updated, calculated and saved allowing for near limitless potential for integration with TruePlanning.  That said it is an “API” which means some programming will need to be done. This discussion is focused on how to get started using the TruePlanning COM API.

Development Environments:

The TruePlanning COM API is written in C++, but is available to any programming environment that can work with COM.  Such environments include Visual Studio for the .NET languages, unmanaged C++, java and Visual Basic for Applications (VBA).

For the purposes of this discussion, VBA from Excel will be used as it is the most ubiquitous development platform in Windows. Anyone with Excel can make use of the TruePlanning API and Excel is the most common application users need to integrate with TruePlanning.  It is also very forgiving and requires the least experience to start creating amazing integrations with TruePlanning.

Creating a TruePlanning project through VBA:

The following steps will prepare the Excel VBA environment to use the TruePlanning COM API (TPCOM), create a project, and then save that project.  Excel 2007 is the version of Excel being used in this discussion. If a different version is being used some of the screen shots may look different, and some of the set up steps will be different, but the code is shown will work.

So let’s get going creating an integration between TruePlanning and Excel!

1. Launch Excel.
2. Open a new workbook.
3. Using “Save As”, save the workbook as an “Excel Macro-Enabled Workbook (*.xlsm)” file.
4. Display the “Developer” ribbon. To do this:
   1. Click the “Windows” button (round button on the top left of the Excel window, with the multicolored Windows icon).
   2. Click the “Excel Options” button at the bottom of the Excel Windows menu.
   3. Check the “Show Developer tab in the Ribbon” checkbox.  (See screen shot following this set of instructions.)
   4. Click Ok.

5. Select the “Developer Ribbon”

6. Click the “Insert” ribbon button. This will display a set of controls that can be added to the Excel sheet.

7. Select the “Command Button” from the ActiveX Controls section of the Insert menu.  It will be the top left item in the bottom half of the Insert menu.

8. Your cursor will become a “+”. Click somewhere on Sheet1 and drag to size the command button. Release the mouse button. As this is VBA, the bigger the button the better!

9. Double click the button to create a macro. This will launch the Microsoft Visual Basic for Applications design environment.  You will see code has been created to handle the event of the button being clicked.

10. Create a reference to the TruePlanning COM object.  In order to use the TruePlanning API, the current code base needs to be told that it is going to be used. To do this we will create a reference. In other programming environments this process will be a bit different, but the result will be the same. In Excel the following steps will create the reference:
    1. Click the Tools menu in the Microsoft Visual Basic for Applications design environment.

2. Click the References option. This will launch the references dialog.

3. Locate the “TruePlanningApi 12.1 Type Library” and check the checkbox in front of it to select it.
4. Click OK.

11. View the TPCOM object in the “Object Viewer”.  The Object browser is a great resource for learning about the objects in the TPCOM API. To use it follow the following steps:
    1. Select the “View” menu in the Microsoft Visual Basic for Applications design environment.
    2. Select the “Object Browser” options, or you can just press “F2”.
    3. Use the pull down in the top left of the Object Browser window to select “TruePlanningApi”.  (See following screen shot.

4. The Object Browser has three panes. The top left pane shows the objects in the API and the top right shows methods and properties of the object selected in the left pane.  In the above screenshot the “Cost Object” object is selected and its methods and properties are displayed in the right pane.
5. At the bottom of the Object Browser window the third pane contains details about the currently selected method or property. In the above screen shot the arguments for the “New” method of the “Cost Object” object are seen. 
6. Click the “X” button on the top right of the Object Brower window to close it, or double click on the “Sheet1 (sheet1)” entry on the left most pane of the VBA design environment. This will return focus to the code for the button that has been created.

12. Create an instance of the TruePlanning application:
    1. The first step in using the TruePlanning API is to create an instance of the TruePlanningApi.Application object.
    2. Add the following code:

   Dim app As TruePlanningApi.Application

   Set app = New TruePlanningApi.Application

3. The above code defines a TruePlanning Application variable and instantiates it (gives it life).

13. Create a TruePlanningApi.Session object.
    1. The TruePlanningApi.Session object represents an open TruePlanning application. To open TruePlanning a connection must be made to the database. The TruePlanning application uses connection information stored in the registry. When using the TruePlanning API the connection name must be provided. The TruePlanningApi.Application object can supply a list of available connections. In this case we’ll use the default connection name.
    2. Declare and instantiate a TruePlanning.Session object. The TruePlanningApi.Application’s “Login” method takes the name of a connection and returns a TruePlanning.Session object.
    3. Add the following code:

   Dim ses As TruePlanningApi.Session

   Set ses = app.Login("(local)")

4. Test the code that was added for validity by using the “Debug->Compile VBA Project” menu option.

14. Create a new project.
    1. A TruePlanningApi.Project object represents a TruePlanning project. It contains all of the components of projects found in TruePlanning including Cost Objects, Worksheet Sets, Local Escalations, a country, and a note.
    2. New projects are created from the collection of projects maintained by the TruePlanningApi.Session object. They are returned from the “New” method on the TruePlanningApi.Projects collection.  The “New” method requires at least a name for the project. Optional arguments are a country and an escalation set.
    3. Declare and instantiate a TruePlanning.Project object:

   Dim proj As TruePlanningApi.Project

   Set proj = ses.Projects.New("MyNewProject")

4. Calling the New method on the Projects collection will create a new TruePlanning project in memory. Note: that that at this time the project has not been saved so if the code were to stop executing at this point, the project would no longer exist.
5. NOTE: If the provided project name is a duplicate of a project name that already exists for the user currently executing the code, the TruePlanning API will rename the project to make the project name unique. It is important to understand this because this can lead to unexpected behavior, particularly if there is code that is assuming a project name.  It is a good idea to check the project name after the project has been created.

15. Display the name of the newly created project:
    1. Display the name of the newly created project by displaying it in a message box by adding the following code:

   MsgBox (proj.Name)

16. Save the project:
    1. Save the project by adding the following code:

   proj.Save

17. Close the project:
    1. When a project is no longer needed the project needs to be closed. It is important to note that closing a project does not cause the project to be saved automatically. It is up to the programmer to ensure projects are saved before being closed. Any changes to a project that were made since the last save will be lost if a project is closed before it saved. Projects that were never saved will be lost for good.
    2. Projects that are not closed are left in a locked state. This can happen when code crashes. If a project is left in a locked state the only way to release the lock is to use the Project Manager dialog in TruePlanning, right click on the locked project and select the “Release Lock” right-click menu option.
    3. To close a project call the “Close” method on the TruePlanningApi.Project by adding the following code:

proj.Close

18. Close the Session.
    1. Closing the session is like closing TruePlanning. The connection to the database is closed. All memory used by TruePlanning is released. Just as it is important to close a project, it is also important to close the session.
    2. To close a session call the “Logout” method on the TruePlanningApi.Session object by adding the following code:

ses.Logout

19. Complete the code by ensuring all memory is released.
    1. It is a good practice to ensure as much memory has been release as possible. In VBA to do this, all variables that make use of the “Set” keyword need to be set equal to “Nothing”. So in this example, the app, ses, and proj variables were set equal to TruePlanning API objects using the “Set” keyword and therefore need to be set equal to “Nothing” after they are no longer needed, which in this case is the end of the click event.
    2. Use the following code to accomplish this:

   Set proj = Nothing

   Set ses = Nothing

   Set app = Nothing

20. Test the Code:
    1. Select the first line in the CommandButton1_Click method.
    2. Press the “F5” key.
    3. This will run the code as if the button that was created had been clicked.
21. Debugging the code:
    1. To debug the code, place debug points in the code by clicking in the grey bar to the left of the code window:

2. When the code is executed and the line with the breakpoint is hit, the code will stop execution and the VBA development environment can be used to examine the code.
3. Pressing “F8” will advance the code, stepping into any functions that are called.
4. Pressing “Shift-F8” will advance, but will not step into functions or subroutines.
5. Pressing “F5” will cause the code to continue running until another breakpoint is hit or until the code complete.
6. Test this by clicking on the command button that was created. Immediately after the button is pressed the VBA development button should come into focus with the line of code with the breakpoint highlighted in yellow.

22. Complete Code:
    1. The complete code should look as follows:

Private Sub CommandButton1_Click()

   Dim app As TruePlanningApi.Application

   Set app = New TruePlanningApi.Application

   Dim ses As TruePlanningApi.Session

   Set ses = app.Login("(local)")

   Dim proj As TruePlanningApi.Project

   Set proj = ses.Projects.New("MyNewProject")

   MsgBox (proj.Name)

   proj.Save

   proj.Close

   ses.Logout

   Set proj = Nothing

   Set ses = Nothing

   Set app = Nothing

End Sub

Conclusion:

In the end the above steps are not particularly complicated.  After working with the above code. the use of the TruePlanningApi Application, Session, and Project objects will become second nature. The above steps, while detailed, really take minimal time to set up and allow users to perform very powerful tasks with TruePlanning.  Questions can be sent to help@pricesystems.com.

Thank you,

PRICE Systems L.L.C.

 In my research on project management and cost estimation, I often come across three different “breakdown structures” which are useful in dissecting a project from various points of view.  The work breakdown structure (WBS) is oriented around project deliverables; it breaks a system down into subsystems, components, tasks and work packages.  The organization breakdown structure (OBS) shows the structure of the organizations involved in the project, including how these organizations break down into sites, divisions, teams, etc.  Finally, the cost breakdown structure (CBS) examines a project in terms of useful cost categories, such as budget appropriations.

These structures are useful for a variety of tasks.  The WBS aids in defining scope and developing project plans.  The OBS clearly defines the different groups involved in the project, and how they are relate to one another.  The CBS is useful for project budgeting.  Upon studying the relationship between these structures, a picture of a cube emerges, which yields more useful insights.

Looking at the intersection of the WBS and OBS, you can get a clear understanding of who is assigned various responsibilities, which clarifies ownership of tasks and facilitates communication.  The intersection of the CBS and the OBS can help you monitor budgets across divisions of your organization.  The WBS and CBS join to show how the project breaks down according to your budget and colors of money.  Each of these three structures is inherently related, and one major feature tying them together is that each structure is inextricably linked to cost.

For an organization to have successful cost management, the decision-makers must truly understand the costs involved.  Since all three structures are used by various decision-makers, cost estimates must be organized to match their unique point of view.  Structuring a cost estimate such that it can be mapped to a WBS, OBS, and CBS is crucial in supporting cost management.  As a cost researcher and designer of cost estimation solutions for TruePlanning, these ideas are considered when designing new solutions.  In my next blog, I’ll dig further into the relationships between these 3 structures as it relates to estimating Total Ownership Cost.

Recently I have been playing around with the International Software Benchmark Standards (ISBSG) database for Development and Enhancement projects.  And in the interest of full disclosure I admit that I am more than a little excited to have close to 6000 data points at my fingertips.  I will further admit that there’s something quite daunting about having this much data; where to start, what should I be looking for, how can I best use this data to offer some useful guidance to inform software cost estimation.  For those of you not familiar with this data source, the ISBSG database contains data on software projects submitted from software development organizations all around the world. 

Naturally, the first thing I wanted to do was look at Project Delivery Rates (PDR) and try to find some interesting information about what might drive PDR.  Starting small (ish) I filtered the data to eliminate all those data items which the ISBSG has rated as of low or questionable quality and filtered all those projects which had included in their labor totals hours for resources not strictly part of the development team.  I started by trying to trend Functional Size with PDR.  The data was all over the map. In an effort to get some context as to where the good data might be lurking, I began to look at average PDR rates for each Organization Type.  I selected Organization Type because this seemed to be the most granular category that had some structure to it.  Organization Type is intended to indicate the type of organization that the software application is intended for.  Although an Application Type is provided, this value is free form with each submitter choosing their own terminology.  The same is actually true for Organization Type but because of the submission process there was a finite set of responses which could be used as a basis of stratification.  Although the ISBSG data is measured using functional size measures, the list of ISBSG acceptable Functional Size Measures is long and includes IFPUG, NESMA, COSMIC, Mark II, FiSMA, etc.  In order to compare apples to apples my analysis needed to focus on each size unit individually.  I started with IFPUG because this group contains significantly more data points than any other functional measurement category.  I thought I would share some initial findings.  The following table shows the productivity rates for various Organization Types. 

So what does this table tell you?   It certainly needs to be interpreted with care as you will note that for many of these productivity rates the distribution is all over the map.  For industries where the sample size is significant it gives some pretty interesting comparative information.  It also provides some useful information into the types of industries for which you can find data in the ISBSG database (not inclusive because this did not cover all the data points – only the IFPUG ones)  There is also the caveat that for different submitters have different ideas about definitions of things like industry type.  Despite that I think there’s something to learn here.  If you’re interested in data, and who isn’t you should check out the ISBSG’s offerings – they have a pretty cool arrangement using an OLAP interface to allow you to find and pay for only the data you can use.  Check it out at www.isbsg.org !! 

And I'm just getting started - check back for more observations on software productivity!

When software developers first starting writing programs for the Windows ® Operating System it wasn’t pretty.   Everything had to be done from scratch – there was no easy access to tools, libraries and drivers to facilitate development.  A similar tale can be told by the earliest web site developers.   A web application framework is an SDK (Software Development Kit) for web developers.  It is intended to support the development of web services, web applications and dynamic websites.  The framework is intended to increase web development productivity by offering libraries of functionality common to many web applications.  In the early days web development was done in HTML with CGI (Common Gateway Interface) making it possible to create dynamic content.  As websites became more pervasive, in fact in many cases they quickly became critical to the success of a business, new languages were developed specifically for web development such as PHP and Cold Fusion.

Web application frameworks are merely the next generation of web development.  Instead of being just a compiler, the web application framework gathers libraries of functionality useful for web development into a single environment – offering developers one stop shopping for the tools they need to develop applications for the web.  There are many different web application frameworks for many different web development languages.  Some examples include JavaEE, Open ACS, Catalyst, Ruby On Rails and Symfony

Web application frameworks offer a variety of features intended to increase productivity of the web application development process.  Not all frameworks contain all of these features – [3] contains a fairly comprehensive analysis of which frameworks offer which features for many popular programming languages.  The most common features of a web application framework include:

•  Caching – frameworks allow developers to build speed into their web applications by storing copies of frequently accessed data to speed up refreshes.  This can make the website appear to load more quickly, while also reducing bandwidth and load.
•  Security – frameworks offer tools to address user authorization and authentication along with  the ability to restrict access based on established criteria
•  Templating – frameworks offer the developer the ability to create templates for their dynamic content.  The templates can then be used by multiple data sets.
•  Data persistence – frameworks often contain a set of features to support persistence such as consistent Application Programming Interface(API) for accessing data from multiple storage system, automated storage and retrieval of data objects, data integrity checks, and SQL support.
•  URL mapping – frameworks often provide a mechanism to map URLs from a clean and uncomplicated looking url to one that leads to the right place.
•  Administrative tools such as common interface elements to form fields such as a date field with calendar and automatic configuration which eases the storage and retrieval of data objects from the database

Web applications frameworks are intended to increase the productivity of those folks who build websites.  Other potential benefits include: 

•  Increased abstraction - business logic can be separated from implementation details
•  Increased time to market and development productivity
•  Increased reused
•  Enforced best practices
•  Ease transition from one platform to another

Some or all of these features and benefits are realizable depending on the specific web application framework employed.  As with all advances in technology, there is necessarily an investment in not only the technology but more importantly in training and education.  It is not realistic to expect immediate payoff until developers move down the learning curve with the technology.

As always, it is wise to remember the lessons of Fred Bookes in "The Mythical Man Month" that there are no silver bullets.  While Web Application Frameworks features of enhanced tools and libraries will increase the productivity with which code is delivered, these remain the accidental complexities of software engineering; the essential complexity of crafting a software solution to a problem is not going away.

I have recently being following an animated thread on LinkedIn “Death of a Metaphor – Technical Debt.” It’s been live for 2 months with over 200 contributions from dozens of different people.  The discussion was launched by questioning whether continued use of this metaphor makes sense.  The discussion thread weaves and bobs around actually answering this question but it’s amazing how passionate the world is on this topic.  My personal opinion is that it’s a perfectly adequate metaphor because it helps create a discussion between IT and the business leaders in terms that both can understand – dollars and cents. 

Sometimes during software development decisions are made to forgo structural quality to meet some other objective – additional functional requirements, time to market, etc.  How many of us have been involved in a development project where it was more important to get the product out the door than it was to get it done right – we take short cuts with the intent to go back and do it right once the immediate fire drill is over.  The problem is that once the product is out the door and meeting the customers expectation - how do we convince the business that there is as much (maybe more) long term value in fixing a product that is seemingly working than in investing in new features that will make the product more appealing to more users.  What business leaders may not understand is the cost of continuing to maintain and grow a structurally questionable - sometimes brittle – application.  Technical debt is the monetization of that cost making it possible for IT to communicate the value to the business of creating and maintaining a structurally sound application.  Check out this blog for a good discussion of technical debt and how to prevent accruing it.  “Technical Debt gets the Message Across”. 

The IEEE published “Top 11 Technologies of the Decade” in the  January 2011 editions of the IEEE Spectrum magazine.  It should come to a surprise to no one that the Smartphone was number 1 on this list.  The answer to the author’s question “Is your phone smarter than a fifth grader” was a resounding YES![1] 

 In 1983 Motorola introduced the first hand hell cellular phone.  It weighed in at two and a half pounds, had memory capacity for 30 phone numbers, took 10 hours to recharge and had a selling price of $4000 ($8045 in 2006).  The phone was the size of a man’s head and would sustain an hour of conversation before a recharge was required.  In June of 2007 Apple announced that it was launching the iPhone which would basically integrate all of the electronic gadgets teenagers carried around in their pockets into a complete package – phone, web browser, iPod and camera.  The iPhone 5 which should be available by Fall 2011 incorporates NFC technology, an upgraded operating system with cloud integration, music streaming, voice interface, 4G connectivity and an embedded social networking tool. NFC technology makes it possible to use the phone effectively as a credit card – making payments by swiping the phone near a device that can read its information. [2][3][4][5]

The proliferation of smartphones and tablets has led (and will continue to lead) to the proliferation of mobile applications.  And it seems as there are no bounds to the kinds of applications that are being developed for smartphones.  A sampling of some popular applications is listed below:

* Chase Mobile – which allows users to check account balances and review transactions
* Angry Birds – very popular gaming software
* Facebook - allows users to report their status from anywhere
* Yelp – allows users to locate places to eat, shop , etc. along with reviews from local patrons of said establishments

The list goes on but clearly if you can dream it – there’s an app for that (or at least there could be an app for that).  As practitioners in the art of estimation, all this mobile application development leads to the inevitable question of what does it cost to develop mobile apps and how is mobile application development different from more traditional forms of development? 
Mobiles apps can be categorized as either native applications – which run entirely on the device or web applications - with small clients resident on the device which interact with applications running on a remote server.  It appears that in general the web applications are less complex than the native ones, and thus less effort is required to build, test and deploy them.
While mobile application development is still in its infancy so a lot of what is going on in the industry now has a bit of the Wild West feel to it.  This stage of any technology is impacted by learning curve issues which may dampen productivity but at the same time there is the newness factor – where smart people are excited about the promise of new technologies and are willing to work extra hard to make things happen.  So while there is some effort/cost data available for mobiles apps, we must temper our enthusiasm.
Another concern when developing mobile applications is which platform(s) it is being developed for.  If an application is being developed for iPhone, Android and Blackberry the effort is significantly increased.  Although there are elements of the design that can certainly transcend platforms, each of these platforms has its own operating system and development environment. There are additional potential compatibility issues in cases such as Android where there are multiple companies manufacturing devices. Additionally, application developers need to determine which versions of OS for each of the platforms the application will work with.  They also need to be aware of and respect the user interface guidelines developed for the device(s) for which they are building apps.
Mobile applications may need to respond to various forms of external data from sensors, a real or virtual keypad, a GPS, microphones, etc.  They also may need to respond to movements of the actual device as well - so the screen adjusts when the user changes the orientation of the device.  There are also many instances where mobile apps will need to interact with other applications on the device.  Often the mobile application will need to share elements of the user interface with other applications. 
Mobile applications need to be developed in such a way as to limit the consumption of resources.  No matter how good your killer app is, if it drains the phone battery in half an hour no one is going to use it.  Along with all other applications that have access to the Internet, they should be built with a focus on security so that the users data is protected from malicious intrusions.
All of the issues listed above are likely to impact the complexity of the development effort of the mobile application – thus they have the potential to be an important part of the cost equation as well.  In many cases mobile applications are smaller than traditional applications so increased complexity may be offset because the projects and corresponding project teams are small.  Still this increased complexity is important to consider.
Another area where mobile apps are dramatically different than traditional apps is in the testing of the application.  Simulators and emulators exist and can be helpful in some circumstances but they are not always easy to use, effective or efficient.  There are also issues, with some platforms around the maturity of the technology that allows applications to be transferred from the development environment to the mobile device – further complicating the testing process.  Finally there is just the sheer magnitude of making sure that the application functions correctly on all the combinations of hardware, operating system and carriers on which it will be expected to perform.  The cost and effort associated with testing may present significant differences when being evaluated for mobile applications.
Smartphones are here to stay and more and more businesses will want (or need) to develop apps for them in order to remain competitive.  With the technology still relatively immature there is limited data that will help us develop cost models but there is feedback from the field on what issues are most likely to impact costs.  Though the technology is still emergent – there is some data available from commercially based mobile app developments – so at least we have a place to start.
Share your experiences with mobile application development by leaving a comment for this post.

[1] Ross, Philip E., “Top 11 Technologies of the Decade”, IEEE Spectrum, January 2011
[2]  http://www.motorola.com
[3] http://www.apple.com
[4] http://en.wikipedia.org/wiki/Mobile_phone
[5]http://www.ibtimes.com/articles/170418/20110628/quick-look-at-iphone-5-features-as-september-release-date-looks-probable-nfc-camera-8mp-lte-4g-displ.htm

Check out this Report on Big Data from McKinsey & Company published in June 2011. 

Back in the day, when personal computers were becoming widely accepted and Microsoft Windows© was the new cool thing, SneakerNet was a common means of sharing data.   Certainly the introduction and subsequent improvements of networking technology and the Internet have made data sharing a whole lot easier and quicker.  But the concept of Big Data creates a whole new level of opportunity and potential for collecting and using data in ways heretofore unthinkable.

So what is Big Data?   According to the report referenced above – “Big Data” refers to datasets whose size is beyond the ability of typical database software tools to capture, store, manage and analyze.  The authors are cautious not to declare a specific size since lightening fast technology advances may quickly make their number wrong thought they do propose currently that datasets in the few terabytes to several petabytes (1000’s of terabytes).  (hmm… I just had to add petabytes to my Word® 2007 dictionary).  The concept of Big Data requires the collection of data from multiple sources (sensors, smartphones, GPS’s, social media postings, data collected by government agencies, etc.) and performing analysis of that data in ways that will make life better and bring more value to businesses, consumers, citizens, etc.
Some examples of Big Data types of applications include;

* Marketing  initiatives like Amazon.com’s “you might also want …” admonition based on information available about your buying patterns and the buying patterns of those purchasing the same item

* Applications like RedLaser which lets a shopper scan a bar code of an in-store item with their smartphone and get immediate price and product comparisons

* Improved supply chain management through access to data across the supply chain helping manufacturers optimize planning and delivery of new products

* Mobile phone apps that allow merchants to track customers from the moment they enter the store to determine traffic patterns and flows through shelves and displays

* Capabilities like OnStar ® where sensors in the automobile send real time data to the service if the airbags deploy or to alert that a system is malfunctioning.

* Capabilities like ShopAlert that sends coupons or offers to smartphones of subscribers when they are in the vicinity of a store, restaurant or bar

The report actually contains a lot more examples across various platforms and sectors.  They have specifically Health Care, Public Sector, Retail, Manufacturing and the ever growing business of using personal location data.  Within each of these categories – opportunities for creating value as well as potential barriers to adoption are presented.

While the technology and the possibilities create lots of excitement – there are also some areas of concern – how much personal data is too much and how close do we want “Big Data” to look like “Big Brother”.   Certainly there are lots of issues that need to be addressed at all different levels before Big Data goes wildly mainstream – but it seems to me that the possibilities for value and capability will, in many cases, be worth it. 

How have you seen Big Data used?  What possibilities can you see for Big Data applications?  Leave a comment to this post to share your Big Data stories.

PRICE Systems is involved with the formulation of the total Life Cycle/Whole Life of systems of systems and is asking the question, "Is the META 'V' on the right track?"

INCOSE is considering the total life of the system, the traditional Development Engineering V must be expanded to account for the life of the system beyond Initial Operational Capability.  In this writer's opinion, we have to extend the development V to account for this with this Meta-V concept.  The Affordability Working Group recognizes that IOC is:

·        The initial release of both the Primary and Enabling system; and the initial release of a successful system continues to evolve to meet environmental changes. Further, monitoring and feedback are integral parts of the evolutionary process.