ZebraSoft Project Management White Paper ®
Table of contents
Executive summary
Overview
Concept and Approach
Body of Knowledge
OO and OOD Concept
PM Data Type
PM Primitive and Derived Data
Types
PM Methods and Statements
PM APIs
PM Classes
PM Model
Objects
Advantage and Savings
Tools
Executive summary
The goal of this white paper is
to put our ZebraSoft approach to project management in a nutshell. Project
management is not a concrete science yet; Object Oriented (OO) and Object
Oriented Design (OOD) are the best approach to software development and design;
management is an art where individuality and style are important keys in
managing projects. We at ZebraSoft.com have combined all these aspects into an
approach that satisfies all that we mentioned. Our ZebraSoft Project Management
Framework (ZPMF) provides a concrete structure, a methodology, a framework and
a body of knowledge for companies to implement, customize, inherit, learn from
and cut/paste into their existing project management with very little changes
and minimum cost. We are basically turning project management into a language
similar to Java with its own data types, methods, classes and APIs. Project
managers will be designing, programming and managing their projects similar to
what Java architects and analysts do in designing and developing software
projects.
Overview
Project Management (PM) is an
emerging profession and as we have mentioned it is not a concrete science yet. Project Management is still in its
development stage and companies and institutes are making all kinds of claims.
New techniques, methodologies and tools are introduced on a daily basis. There
is a number of institutes such as
Project Management Institute (PMI)®
are
working on standardizing PM and producing a general acceptance of body of
knowledge and practices. Project Management for software development is even a
newer and faster merging profession due to the demands on reducing the cost of
software projects.
ZebraSoft.com is introducing
ZebraSoft Project Management Framework (ZPMF) as a framework for PM for
software development. ZPMF helps companies with the following:
·
Concept
·
Body of Knowledge
·
Structure
·
Methodology
·
OO and OOD Approach
ZebraSoft uses Object Oriented
(OO) and Object Oriented Design (OOD) to PM approach. Our ZebraSoft approach is
to create PM objects that can be used directly, inherited, learned from, or
cut/paste into other PM objects. Like OO and OOD, ZebraSoft uses divide and
conquer of big projects into smaller and more manageable subprojects.
ZebraSoft is using real world practices,
tools and techniques to help companies and project managers visualize the
concept and have hands-on practices. Companies and project managers can employ
ZebraSoft methodologies, techniques, approach and examples in several ways: use
them directly in their software projects, copy (cut/paste), learn or build
their own. This can be done with little changes and minimum cost to companies’
existing structures. It can also help companies build management and software
development structures or fine-tune their existing ones.
Concept and Approach
Object Oriented and
Object Oriented Design Approach:
The approach is as
follows:
1. Divide
the program into logical parts, which are called classes
2. Each
part (class) is totally independent of the rest of the program.
3. Each
part (class) has its own data and methods enclosed within it.
4. Data
and methods within any part are hidden and cannot be modified by any code
outside the class.
5. You
can use any of these parts (classes) by simply calling the part name and adding
the task (method) name to the part.
6. The
program has one "manager" method that manages the entire program.
7. Classes
can inherit preexisting classes.
The OO approach is to
divide and conquer a large program into smaller and manageable classes. The OO
approach for PM is to divide the PM into classes that has data and methods. The
data is the Workers, Artifacts, Report, Doc, …etc. The methods are the Project
Management Institute (PMI) processes® such as “Scope Planning”. Each class is an
independent entity that can be used, inherited or instantiated the way Java or
C++ classes are used.
Body of Knowledge
Like PMI® we are providing a ZPMF
Body of Knowledge (ZBOK) which has the needed material for both the new and
experienced project managers to read and use as a reference. ZBOK is a
guideline which contains some of our real world experiences.
OO and OOD Concept
The main idea behind OO and OOD is
that the design and the code are done only once and reused repeatedly by the
creation of instances of a class (object) or by inheritance the same way genes
are passed from parents to children. OO gives the inheritee the option of using
the code or overriding (changing) the code to fit its needs. ZPMF has all the
needed classes for any project manager to reuse or inherit as well as do any
changes to fit the project needs and the management style and approach. For
example, a project manager can use ZPMF classes directly into the project or
inherits ZMPF classes as well as overrides its methods and data. The project manager
can create more than one instance of the Risk class; each instance (object) is
for a different project risk. This means that the ZPMF work is done only once
and it can be used repeatedly.
PM Data Type
Any programming language is
composed of data types, which are the building blocks of the language
itself. Type is a set of values and
operations a data type may have. For example, Java has integer, float, double
and char (character) as its primitive data types. These types are used to store
and manipulate data.
PM Primitive and Derived Data Types
Data types can be primitive and
derived data types. Primitive data types are the basic building blocks that
cannot be broken-down any farther such as an integer in Java. A derived data
type is made up of primitive data type like a Java array of integer.
ZPMF has its own primitive data
types, which are the building blocks of its language and structure. For
example, Workers or Artifacts in a software project are data that are used to
create Activities and Workflow. Therefore, ZPMF primitive data types have
Worker and Activity as some of its types. While Activities and Workflow are the
ZPMF derived types, since they are composed of primitive data types. ZPMF has a
number of primitive data types and the following are some of them:
1.
Date
2.
Contact
3.
Decision
4.
Worker
5.
Artifact
6.
Event
7.
Dependency
8.
Document
9.
Report
Each of the primitive data is
composed of a table of characteristics the same way and integer is defined in
Java or C++ (as the programming language compiler makes a table for its types).
ZPMF has primitive and derived
data types that are used the same way Java uses integers and arrays of
integers. ZPMF primitive and derived types are used to store and manipulate the
project data. ZPMF has a number of derived data types and the following are
some of the declaration of the derived data type:
DerivedDataType Monitor
{
Date
Contact
}
//---------------------------------------
DerivedDataType DecisionMaker
{
Date
Contact
Decision
}
//---------------------------------------
ZPMF uses OO syntax and semantics
to define data type.
PM Methods and Statements
According to PMI® , projects are
composed of processes. A process is:
“a series of
actions bringing about a result”
ZPMF has the same approach as PMI® ,
but we are using OO methodology and way of thinking. ZPMF uses methods and
statements to do the same tasks of the PMI processes® , where they can be grouped
into classes that can be inherited or their methods overridden (modified). This
OO approach gives project management an OO and OOD structure and a way of
thinking. Project managers can create instances of PM classes (objects) and use
its methods the same way a Java programmer uses Sun Microsystems classes and
methods.
Method:
A method is collection of
statements (tasks) that are performed on a data type. The method has a name. It
has a heading and body. The method heading contains the method name and
parentheses with arguments passed to the method. The body consists of “open”
and “close” curly brackets which contains zero or more statements as follow:
scopePlan(argument
list …)
{
statement; // zero or more statement
….
}
A method can be called or invoked
0 or more times. Methods may take zero or more arguments as a parameter list.
scopePlan(); // no argument
scopeDefinition();
scopeDefinition(Document
[] documentHandle);
Statement:
A PM statement is an instruction
or a task for a manager or a worker to perform. A method may have 0 or more
statements. A statement must end with a semicolon “;”.
PM APIs
A Java API is an Application
Programming Interface, which is a method (code) that is given by Sun
Microsystems for Java programmers to use in their application development. ZPMF
is using the same approach and creating API for PM.
API = Assignment
Programming Interface.
ZPMF has created two sets of APIs.
The first is all the PMI processes® and the second ZPMF own APIs. A project team
can use any of the two or create their own APIs the same way code libraries and
utilities of APIs are created in software development. This is an excellent
approach for the following:
1.
Standardizing methods, statements and classes
2.
Standardizing project management
3.
Standardizing project structure
4.
Freedom for project managers to use or override APIs.
5.
Quick updating by downloading APIs the same way Sun
Microsystems website is providing Java’s latest and the greatest using the
Internet.
6.
Special projects may use these APIs, or develop their own.
7.
Cut/paste of APIs to speed PM structure and development.
PM Classes
A class provides a new way of declaring a data type
that has functionality. The class data type contains both the data types and
the methods that perform certain tasks on the data. A class is a way of
grouping logical data and the associated methods within one object (class).
Class “Class-Name”
{
member data list - 0 or more
// Members are
known as properties
//-----------------------------------------
member interfaces - 0 or more
//-----------------------------------------
member method list - 0 or more
}
Member Data List
1.
Arrays of Data types
2.
Arrays of Derived
Data types
3.
Class - Pre-declared
classes
4.
Initializer
PM_Base Class
PM_Base is a special class and it
is the parent class of all the project classes. All the classes share one
PM_Base and its main function is to provide:
1.
Communication
2.
Monitoring
3.
Start and end dates
4.
Shared resources
5.
Visibility
6.
Visibility Modifiers
7.
Scope
8.
Flagging of errors
9.
Exceptions
10. Conflicts
11. Problems
12. Illegal Action
13. Interface
14. Progress
PM_Base class is the main
depository of all data for the project. Its main functionality is sharing,
controlling and resolving conflicts.
The following anchor will open a
window for the actual PM_Base class declaration for ZPMF.
PM_Base Class Declaration
Instance
An object is an instance of class.
There may be 0 or more instance of one class.
PM_Base is the exception; in any
project there is only one PM_Base object that all the other objects share.
Interface
An interface is a shared boundary
where independent systems meet and act on or communicate with each other.
Interface “Interface-Name”
{
Member List - 0 or more
Common
boundary - 0 or more
Dependencies -
0 or more
}
PM Model
Open ZPMF Model
The ZPMF model is graphic
representation of classes and their hierarchal order in term of classes and
their parents and children. We will briefly give a description of the model,
but the reader may have to know OO inheritance rules to fully understand its
composition. The PM_Base class is the
parent of all the classes and it is known as the super-class of the PM design. It
is inherited by the Inception class, which launches a number of methods that
are essential to the classes that follow or inherit it. The next level of
hierarchical is a set of classes that inherit the Inception class. The arrows
show that the lower classes are the children of the upper ones. The same thing
applies to every level until the bottom level. Note that only the Management
class inherits the entire row of classes above it. It shows how anyone can
design the PM structure and control the inheritance and accessibility of the
parent class methods and data. For example, the Management class has access to
the classes in the row above it and it has the right by inheritance to access
all of its parents’ class methods and data including the super PM_Base class.
The Iteration and the Closing classes are last and they inherit all the above
classes. The Development Plan class can only access the following:
1.
PM_Base
2.
Inception
3.
Resource Plan
4.
Activity Plan
5.
Scope Plan
OO helps set a structure to the PM
and provides control over data and methods and not everyone in the hierarchal
has access to all the classes’ data and methods.
Objects
An instance of a class is known as
an object. There can be more that one object for the same class. This can help
structure differently PM for different projects. For example, the Risk class
may have several instances one per project risk instead of creating one Risk
object for all the project risks. This can save a great deal of work and have a
uniform task performance and accessibility to resources.
Advantage and Savings
OO and OOD is a proven tool for
saving code, time, efforts and money. ZPMF is a structure, a design, a
methodology, a way of thinking and an approach that help companies manage their
projects with uniformity and consistence with less conflicts and chaos. The
saving in term of money, time, efforts, dynamic structure using classes and
APIs, and reusability is tremendous. The concept is simple and implementing it
is even simpler. Every class has its methods and data to be performed and the
PM_Base class acts as the Godfather of the project and sets control and solves
conflicts.
Tools
The existing PM tools in today’s
market are not capable of handling such structure. ZPMF can be implemented
using a spreadsheet. We at ZebraSoft are working on a software tool that helps
put everything in motion. But we need financial help or maybe partner with
anyone that can make this happen.