Chapter FourDefining the Project© 2021 McGraw Hill. All ri.docx

Chapter Four
Defining the Project
© 2021 McGraw Hill. All rights reserved. Authorized only for
instructor use in the classroom.
No reproduction or further distribution permitted without the
prior written consent of McGraw Hill.
Because learning changes everything.®
Where We Are Now
© McGraw Hill
‹#›
2
Learning Objectives
4-1 Identify key elements of a project scope statement and
understand why a complete scope statement is critical to project
success.
4-2 Describe the causes of scope creep and ways to manage it.
4-3 Understand why it is important to establish project
priorities in terms of cost, time, and performance.
4-4 Demonstrate the importance of a work breakdown structure
(WBS) to the management of projects and how it serves as a
database for planning and control.

4-5 Demonstrate how the organization breakdown structure
(OBS) establishes accountability to organization units.
4-6 Describe a process breakdown structure (PBS) and when to
use it.
4-7 Create responsibility matrices for small projects.
4-8 Create a communication plan for a project.
© McGraw Hill
‹#›
Chapter Outline
4.1 Step 1: Defining the Project Scope
4.2 Step 2: Establishing Project Priorities
4.3 Step 3: Creating the Work Breakdown Structure
4.4 Step 4: Integrating the WBS with the Organization
4.5 Step 5: Coding the WBS for the Information System
4.6 Process Breakdown Structure
4.7 Responsibility Matrices
4.8 Project Communication Plan
© McGraw Hill
‹#›
Five General Steps for Collecting Project Information
Step 1: Defining the Project Scope
Step 2: Establishing Project Priorities
Step 3: Creating the Work Breakdown Structure
Step 4: Integrating the WBS with the Organization
Step 5: Coding the WBS for the Information System
© McGraw Hill
‹#›

4.1 Step 1: Defining the Project Scope
Project Scope Defined
Is a definition of the end result or mission of your project—a
product or service for your client/customer.
Defines the results to be achieved in specific, tangible, and
measurable terms.
Purposes of the Project Scope Statement
To clearly define the deliverable(s) for the end user.
To direct focus on the project purpose throughout the life of the
project for the customer and project participants.
To be published and used by the project owner and project
participants for planning and measuring project success.
© McGraw Hill
‹#›
6
Project Scope Checklist
Project objective
Product scope description
Justification
Deliverables
Milestones
Technical requirements
Limits and exclusions
Acceptance criteria
© McGraw Hill
‹#›
7

Project Scope: Terms and Definitions
Scope Statements
Is a short, one- to two-page summary of key elements of the
scope, followed by extended documentation of each element.
Is also referred to as “statements of work (SOWs).”
Project Charter
Is a documentation that authorizes the project manager to
initiate and lead the project.
Often includes a brief scope description as well as such items as
risk limits, business case, spending limits, and even team
composition.
Scope Creep
Is the tendency for the project scope to expand over time—
usually by changing requirements, specifications, and priorities.
© McGraw Hill
‹#›
8
Five of the Most Common Causes of Scope Creep
Poor requirement analysis
Not involving users early enough
Underestimating project complexity
Lack of change control
Gold plating
© McGraw Hill
‹#›
9

4.2 Step 2: Establishing Project Priorities
Three major criteria (trade-offs) that a project manager has to
manage are:
Cost (budget)
Time (schedule)
Performance (scope)
A project manager can manage the project trade-offs by
completing a priority matrix for the project and identifying
which criterion is:
Constrain—original parameter is fixed.
Enhance—a criterion should be optimized.
Accept—a criterion is tolerable not to meet the original
parameter.
© McGraw Hill
‹#›
10
Project Management Trade-offs
FIGURE 4.1
© McGraw Hill
‹#›
Project Priority Matrix for the Development of a New Wireless
Router
FIGURE 4.2
Access the text alternative for slide images.

© McGraw Hill
‹#›
4.3 Step 3: Creating the Work Breakdown Structure
Work Breakdown Structure (WBS)
Is a hierarchical outline of the project with different levels of
detail.
Identifies the products and work elements involved in a project.
Defines the relationship of the final deliverable (the project) to
its sub-deliverables, and, in turn, their relationships to work
packages.
Serves as a framework for tracking cost and work performance.
Is best suited for design and build projects that have tangible
outcomes rather than process-oriented projects.
© McGraw Hill
‹#›
Hierarchical Breakdown of the WBS
* This breakdown groups work packages by type of work within
a deliverable and allows assignment of responsibility to an
organizational unit. This extra step facilitates a system for
monitoring project progress (discussed in Chapter 13).
FIGURE 4.3
© McGraw Hill
‹#›
How WBS Helps the Project Manager
Assures project managers that all products and work elements
are identified, to integrate the project with the current

organization, and to establish a basis for control.
Facilitates the evaluation of cost, time, and technical
performance at all levels in the organization over the life of the
project.
Provides management with information appropriate to each
organizational level.
Helps project managers to plan, schedule, and budget the
project.
Helps in the development of the organization breakdown
structure (OBS), which assigns project responsibilities to
organization units and individuals.
Provides the opportunity to “roll up” (sum) the budget and
actual costs of the smaller work packages into larger work
elements.
Defines communication channels and assists in understanding
and coordinating many parts of the project.
© McGraw Hill
‹#›
Work Breakdown Structure
FIGURE 4.4
© McGraw Hill
‹#›
A Work Package
Is the lowest level of the WBS.
Is a short-duration task that has a definite start and stop point,
consumes resources, and represents cost.
Should not exceed 10 workdays or one reporting period.
Should be as independent of other work packages of the project

as possible.
Is the basic unit used for planning, scheduling, and controlling
the project.
© McGraw Hill
‹#›
Each Work Package in the WBS
Defines work (what).
Identifies time to complete a work package (how long).
Identifies a time-phased budget to complete a work package
(cost).
Identifies resources needed to complete a work package (how
much).
Identifies a single person responsible for units of work (who).
Identifies monitoring points for measuring progress (how well).
© McGraw Hill
‹#›
4.4 Step 4: Integrating the WBS with the Organization
Organization Breakdown Structure (OBS)
Depicts how the firm has organized to discharge work
responsibility.
Provides a framework to summarize organization unit work
performance.
Identifies the organization units responsible for work packages.
Ties the organizational unit to cost control accounts.
The intersection of work packages and the organization unit
creates a project cost point or cost account that integrates work
and responsibility.
© McGraw Hill

‹#›
Integration of WBS and OBS
FIGURE 4.5
© McGraw Hill
‹#›
4.5 Step 5: Coding the WBS for the Information System
WBS Coding System
Defines
Levels and elements in the WBS
Organization elements
Work packages
Budget and cost information
Allows reports to be consolidated at any level in the structure.
WBS Dictionary
Provides detailed information about each element in the WBS.
© McGraw Hill
‹#›
Coding the WBS
EXHIBIT 4.1
© McGraw Hill
‹#›
4.6 Process Breakdown Structure

Process Breakdown Structure (PBS)
Is used for process-oriented projects.
Is often referred to as the “waterfall method” in the software
industry.
Process-oriented project
Is a project that the final outcome is a product of a series of
steps and phases.
Is a project that evolves over time with each phase affecting the
next phase.
Is a project that is driven by performance requirements, not by
plans/blueprints.
© McGraw Hill
‹#›
PBS for Software Development Project
FIGURE 4.6
© McGraw Hill
‹#›
4.7 Responsibility Matrices
Responsibility Matrix (RM)
Is also called a linear responsibility chart.
Summarizes the tasks to be accomplished and who is
responsible for what on the project.
Lists all the project activities and the participants responsible
for each activity.
Clarifies interfaces between units and individuals that require
coordination.
Provides a mean for all participants in a project to view their
responsibilities and agree on their assignments.

Clarifies the extent or type of authority exercised by each
participant.
© McGraw Hill
‹#›
Responsibility Matrix for a Market Research Project
FIGURE 4.7
© McGraw Hill
‹#›
Responsibility Matrix for the Conveyor Belt Project
FIGURE 4.8
© McGraw Hill
‹#›
4.8 Project Communication Plan
Project communication plans address the following questions:
What information needs to be collected and when?
Who will receive the information?
What methods will be used to gather and store information?
What are the limits, if any, on who has access to certain kinds
of information?
When will the information be communicated?
How will it be communicated?

© McGraw Hill
‹#›
Steps for Developing a Communication Plan
Stakeholder analysis—identify the target groups.
Information needs—project status reports, deliverable issues,
changes in scope, team status meetings, gating decisions,
accepted request changes, action items, milestone reports, etc.
Sources of information—where does the information reside?
Dissemination modes—hardcopy, e-mail, teleconferencing,
SharePoint, and a variety of database sharing programs.
Responsibility and timing—determine who will send out the
formation and when.
© McGraw Hill
‹#›
Stakeholder Communications
FIGURE 4.9
© McGraw Hill
‹#›
Shale Oil Research Project Communication PlanWhat
InformationTarget AudienceWhen?Method of
CommunicationProviderMilestone reportSenior management and
project managerBimonthlyE-mail and hardcopyProject
officeProject status reports & agendasStaff and
customerWeeklyE-mail and hardcopyProject managerTeam
status reportsProject manager and project officeWeeklyE-
mailTeam recorderIssues reportStaff and customerWeeklyE-
mailTeam recorderEscalation reportsStaff and customerWhen

neededMeeting and hardcopyProject managerOutsourcing
performanceStaff and customerBimonthlyMeetingProject
managerAccepted change requestsProject office, senior
management, customer, staff, and project managerAnytimeE-
mail and hardcopyDesign departmentOversight gate
decisionsSenior management and project managerAs requiredE-
mail meeting reportOversight group or
project office
FIGURE 4.10
© McGraw Hill
‹#›
Key Terms
Acceptance criteria
Cost account
Gold plating
Milestone
Organization breakdown structure (OBS)
Priority matrix
Process breakdown structure (PBS)
Product scope description
Project charter
Responsibility matrix
Scope creep
Scope statement
WBS dictionary
Work breakdown structure (WBS)
Work package
© McGraw Hill
‹#›
End of Main Content

© 2021 McGraw Hill. All rights reserved. Authorized only for
instructor use in the classroom.
No reproduction or further distribution permitted without the
prior written consent of McGraw Hill.
Because learning changes everything.®
www.mheducation.com
Accessibility Content: Text Alternatives for Images
© McGraw Hill
‹#›
Project Priority Matrix for the Development of a New Wireless
Router - Text Alternative
Return to parent-slide containing
images.TimePerformanceCostConstrain
X
Enhance
X
Accept
X
Return to parent-slide containing images.
© McGraw Hill
‹#›
Hierarchical Breakdown of the WBS - Text Alternative
Return to parent-slide containing images.LevelHierarchical

breakdownDescription1
[double-headed arrow]Project
[downward arrow]Complete project2
[double-headed arrow]Deliverable
[downward arrow]Major deliverables3
[double-headed arrow]Subdeliverable
[downward arrow]Supporting deliverables4
[double-headed arrow]Lowest subdeliverable
[downward arrow]Lowest management responsibility level5
[double-headed arrow]Cost account*
[downward arrow]
Work packageGrouping of work packages for monitoring
progress and responsibility
Identifiable work activities
* This breakdown groups work packages by type of work within
a deliverable and allows assignment of responsibility to an
organizational unit. This extra step facilitates a system for
monitoring project progress (discussed in Chapter 13).
© McGraw Hill
‹#›

Work Breakdown Structure - Text Alternative
Level 1 consists of the E-Slim Tablet x-13 Prototype.
Level 2 consists of Hardware, CPU, and More Items.
Level 3 consists of the Power Supply, Flash ROM, and I/O
Controller, all flowing from the CPU in Level 2.
Level 4 consists of the Battery and Charger (flowing from the
Power Supply in Level 3) and the USB Slots, Internet, and
Touch Screen (flowing from the I/O Controller in Level 3).
Level 5 consists of the following components. Lowest
Manageable Subdeliverables are identified with an (*); Work
Packages are identified with a (#).
From Hardware (in Level 2)
• Frame*
o WP-F1#
• Cameras*
o WP-C1#
o WP-C2#
o WP-C3#
o WP-C4#
• Speakers*
o WP-S1#
• Antenna*
o WP-A1#
o WP-A2#
o WP-A3#
From Touch Screen (in Level 4)
• Keyboard*
o WP-K1#
• Touch Sensors*
o WP-TS1#
o WP-TS2#
o WP-TS3#
• Back Light*
o WP-BL1#
o WP-BL2#

o WP-BL3#
• Resolution*
o WP-R1#
o WP-R2#
o WP-R3#
© McGraw Hill
‹#›
Integration of WBS and OBS - Text Alternative
Level 1 consists of the E-Slim Tablet x-13 Prototype [1.0].
Level 2 consists of Hardware [1.1], CPU [1.2], and More Items.
Level 3 consists of the Power Supply [1.2.1], Flash ROM
[1.2.2], and I/O Controller [1.2.3], all flowing from the CPU in
Level 2.
Level 4 consists of the Battery [1.2.1.1] and Charger [1.2.1.2]
(flowing from the Power Supply in Level 3) and the USB Slots
[1.2.3.1], Internet [1.2.3.2], and Touch Screen [1.2.3.3]
(flowing from the I/O Controller in Level 3).
Level 5 consists of the following components, which are the
Lowest Manageable Subdeliverables.
From Hardware (in Level 2)
Frame [1.1.1]
Cameras [1.1.2]
Speakers [1.1.3]
Antenna [1.1.4]
From Touch Screen (in Level 4)
Keyboard [1.2.3.3.1]
Touch Sensors [1.2.3.3.2]
Back Light [1.2.3.3.3]
Resolution [1.2.3.3.4]
The Level 5 components are integrated
into the OBS as shown in the following

table:FrameCamerasSpeakersAntennaKeyboardTouch
SensorsBack LightResolutionDesignCost Account1.1.4.1*Cost
AccountCost AccountCost AccountQC TestCost AccountCost
AccountCost AccountCost AccountCost AccountProductionCost
Account1.2.3.3.2.3Cost AccountOutsourcingCost AccountCost
AccountCost AccountCost AccountCost AccountCost Account
* Cost Account Number
© McGraw Hill
‹#›
Coding the WBS - Text Alternative
Return to parent-slide containing images.[Info icon]Task
ModeTask Name1[right-pointing arrow icon]1 E-Slim Tablet x-
13 Prototype2[right-pointing arrow icon]1.1 Hardware3[push-
pin icon and question mark]1.1.1 Cameras4[push-pin icon and
question mark]1.1.2 Speakers5[push-pin icon and question
mark]1.1.3 Antenna6[right-pointing arrow icon]1.2 CPU7[right-
pointing arrow icon]1.2.1 Power supply8[push-pin icon and
question mark]1.2.1.1 Battery (more items)9[push-pin icon and
question mark]1.2.1.2 Charger (more items)10[right-pointing
arrow icon]1.2.2 Flash Rom (more items)11[push-pin icon and
question mark]1.2.2.1 I/O controller12[push-pin icon and
question mark]1.2.2.2 USB slots (more items)13[push-pin icon
and question mark]1.2.2.3 Internet (more items)14[right-
pointing arrow icon]1.2.3 Touch screen15[right-pointing arrow
icon]1.2.3.1 Keyboard16[push-pin icon and question
mark]1.2.3.1.1 Work package17[right-pointing arrow
icon]1.2.3.2 Touch sensors18[push-pin icon and question
mark]1.2.3.2.1 Work package19[push-pin icon and question
mark]1.2.3.2.2 Work package20[push-pin icon and question
mark]1.2.3.2.3. Work package21[push-pin icon and question
mark]1.2.3.3 Back light (more items)22[push-pin icon and
question mark]1.2.3.4 Resolution (more items)

© McGraw Hill
‹#›
PBS for Software Development Project - Text Alternative
Software development project
• Analysis (1)
• Design (1)
o Define user interface (2)
o Develop technical design (2)
§ Define application architecture (3)
§ Define processing flow (3)
§ Design logical database structure (3)
§ Design system interfaces (3)
o Establish quality requirements (2)
o Develop detailed design (2)
• Construct (1)
• Test (1)
• Rollout (1)
Outputs:
Design phase deliverables
• Design document
o Application architecture
o Application flow
o Database design
o End user interface design
o Workflow diagram
• User documentation outline
==============
Note: Numbers in parentheses indicate the following levels:
(1) Level: Major phases
(2) Level: Activities
(3) Level: Activities

© McGraw Hill
‹#›
Responsibility Matrix for a Market Research Project - Text
Alternative
Return to parent-slide containing images.TaskProject
TeamRichardDanDaveLindaElizabethIdentify target
customersRSSDevelop draft questionnaireRSSPilot-test
questionnaireRSFinalize questionnaireRSSSPrint
questionnaireRPrepare mailing labelsRMail
questionnairesRReceive and monitor returned
questionnairesRSInput response dataRAnalyze
resultsRSSPrepare draft of reportSRSSPrepare final reportRS
R = Responsible
S = Supports/assists
© McGraw Hill
‹#›
Responsibility Matrix for the Conveyor Belt Project - Text
Alternative
Return to parent-slide containing
images.DeliverablesOrganizationDesignDevelopmentDocumenta
tionAssemblyTestingPurchasingQuality
AssuranceManufacturingArchitectural designs12233Hardware
specifications2123Kernel specifications133Utilities
specifications213Hardware design1333Disk drivers312Memory
management133Operating system
documentation2213Prototypes5413334Integrated acceptance
test522155
1 Responsible

2 Support
3 Consult
4 Notification
5 Approval
© McGraw Hill
‹#›
Stakeholder Communications - Text Alternative
High Power, Low Interest: Keep Satisfied (clients D and A)
Low Power, Low Interest: Provide General Information (clients
G and B)
High Power, High Interest: Manage Closely (clients F, H, and
C)
Low Power, High Interest: Keep Informed (clients D and E)
© McGraw Hill
‹#›
image3.PNG
image4.PNG
image5.png
image6.png
image7.png
image8.png
image9.png
image10.png
image11.png
image12.png
image13.png
image14.png
image2.png

image1.png
P1_NoThreads.javaP1_NoThreads.javapackageThreads_Synchro
nization;
publicclassP1_NoThreads{
publicstaticvoid function1(){
for(int i=0;i<20;i++){
try{
System.out.println("function 1 is running for iteration number "
+i);
}catch(Exception e){
e.printStackTrace();
}
}
}
for(int j=0;j<20;j++){
try{
+j);
}
}
}
publicstaticvoid main(String[] args){
//main thread running both function1 and function2
function1();//call function 1

function2();//call function 2
}
}
__MACOSX/._P1_NoThreads.java
Question1_WithdrawDeposit.javaQuestion1_WithdrawDeposit.j
avapackageThreads_Synchronization;
import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
publicclassQuestion1_WithdrawDeposit{
/*
* In this question use semaphore(s) to enable process synchr
onization
*
* Thread 1 and thread 2 (in the main function) share a single
bank account (initial balance of 1000$).
* thread 1 can deposit certain input amount to the balance on
ly if the current balance is less than 2000$
* thread 2 can withdraw certain input amount from the balan
ce only if the current balance is greater than or equal to the inpu
t amount.
*
*/
// shared resources between thread 1 and thread 2 are:
publicstaticint balance =1000;//the initial value of the account's
balance

//DONOT CHANGE THIS VARIABLE
// add below any further resources you think the deposit and wit
hdraw threads/functions must share
//--------------------------------------------
end of shared resources section
// this function simply displays the current balance of the shared
account and which thread made the call
// DONOT CHANGE THIS FUNCTION
publicstaticvoid displayStatus(){
if(Thread.currentThread().getName().equals("withdraw"))
System.out.println("The withdraw function successfully took th
e amount and the current value of the account's balance is :"+ b
alance +"$");
else
System.out.println("The deposit function successfully added the
amount and the current value of the account's balance is :"+ bal

ance +"$");
}
// this function accepts an input integer amount value to deposit
into the shared account
publicstaticvoidDeposit(int amount){
try{
System.out.println("The deposit function is trying to add "+ am
ount +"$ to the shared balance"+ balance +"$");
// Deposit the input amount to the balance only if the current bal
ance is less than 2000$
// Deposit doesn't wait until this condition is true (If the conditi
on is false, skip adding the amount), thus use if statements rathe
r than waiting while loops
// Call the displayStatus() function after you deposit the amount
and before release the lock
// Implement the deposit functionality, as detailed above, in the
area below

//--------------------------------------------end of Deposit function
System.out.println("Problem with the deposite function "+e.toSt
ring());
}
}
// this function accepts an input integer amount value to withdra
w from the shared account
publicstaticvoidWithdraw(int amount){
try{
System.out.println("The withdraw is trying to remove "+ amoun
t +"$ from the shared balance"+ balance +"$");
// withdraw the input amount from the balance only if the curren
t balance is greater than or equal to input amount
// Withdraw doesn't wait until this condition is true (if the condi
tion is false, skip withdrawing the amount), thus use if statemen
ts rather than waiting while loops
// Call the displayStatus() function after you remove the amount
and before release the lock
// Implement the withdraw functionality, as detailed above, in th
e area below

//--------------------------------------------
end of Withdraw function
System.out.println("Problem with the withdraw function "+e.toS
tring());
}
}
// this is the main function
// DONOT CHANGE THIS SECTION
//create thread 1 to run function 1
Thread thread1 =newThread(newRunnable(){
@Override
publicvoid run(){
while(true){
try{
Deposit(200+(int)(Math.random()*1000));//random value betwe
en 200 and 1000$
Thread.sleep(200+(int)(Math.random()*500));//random delay be
tween 200 and 500
System.out.println("Problem with thread 1 "+e.toString());
}
}

}
});
@Override
publicvoid run(){
while(true){
try{
Withdraw(200+(int)(Math.random()*1000));//random value bet
ween 200 and 1000$
tween 200 and 500
}
}
}
});
//ask the threads to start running
thread1.setName("deposit");
thread1.start();
thread2.setName("withdraw");
thread2.start();
}
}
__MACOSX/._Question1_WithdrawDeposit.java
P4_Semaphore.javaP4_Semaphore.javapackageThreads_Synchro
nization;

import java.util.concurrent.*;
publicclassP4_Semaphore{
/*
Important to note:
Mutex Lock in literature uses acquire() and release()
in Java these functions are lock() and unlock() r
espectively
Semaphore in literature uses wait() and signal()
in Java these functions are acquire() and release(
) respectively
*/
//semaphore lock
//counting semaphore with two instances, change the number of
instances and track the acquire/release sequence
publicstaticSemaphore semaphore =newSemaphore(2);
try{
System.out.println("function 1 trying to acquire the lock");
semaphore.acquire();

System.out.println("function 1 acquired the lock ... start the crit
ical section");
//critical section
System.out.println("function 1 Locks remaining >> "+semaphor
e.availablePermits());
//end of critical section
semaphore.release();
System.out.println("exit the critical section ... function 1 Locks
Released");
}
}
}
try{
semaphore.acquire();
ical section");
//critical section
System.out.println("function 2 Locks remaining >> "+semaphor
e.availablePermits());

semaphore.release();
System.out.println("exit the critical section ... function 2 Locks
Released");
}
}
}
@Override
publicvoid run(){
function1();
}
});
@Override
publicvoid run(){
function2();
}
});
thread1.start();
thread2.start();
}

}
__MACOSX/._P4_Semaphore.java
P2_SimpleThreads.javaP2_SimpleThreads.javapackageThreads_
Synchronization;
publicclassP2_SimpleThreads{
try{
+i);
}
}
}
try{
+j);
}
}
}

@Override
publicvoid run(){
function1();
}
});
@Override
publicvoid run(){
function2();
}
});
thread1.start();
thread2.start();
}
}
__MACOSX/._P2_SimpleThreads.java
Question3_SortingArrays.javaQuestion3_SortingArrays.javapac
kageThreads_Synchronization;
import java.util.Random;
publicclassQuestion3_SortingArrays{

/*
* In this question use mutex lock(s) or semaphore(s) to enab
le process synchronization
*
* Thread 1 and thread 2 share a single buffer (1D Array), wh
ere:
* thread 1 sorts the items of the buffer in ascending order
* thread 2 sorts the items of the buffer in descending order
*
*/
// DONOT CHANGE THESE VARIABLE
publicstaticintBufferSize=10;//the size of the buffer
publicstaticint buffer[]=newint[BufferSize];//the shared buffer
// add any further resources you think Ascending() and Descendi
ng()functions must share below
//--------------------------------------------

// this function simply displays the content of the shared buffer
and which thread made the call
if(Thread.currentThread().getName().equals("ascending"))
System.out.println("Ascending successfully sorted the array");
else
System.out.println("Descending successfully sorted the array");
System.out.print(" the "+Thread.currentThread().getName()+" is
displaying the content of the buffer: ");
for(int i=0;i<BufferSize;i++){
System.out.print(buffer[i]+" ");
}
System.out.println();
}
// this function sorts the shared buffer in ascending order
publicstaticvoidAscending(){
try{
System.out.println("The Ascending is trying to sort the shared b
uffer");
// Sort the buffer in ascending order
// Call displayStatus after you sort and before release the lock
// Implement the Ascending functionality in the area below

//--------------------------------------------
end of Ascending function
System.out.println("Problem with the Ascending function "+e.to
String());
}
}
// this function sorts the shared buffer in descending order
publicstaticvoidDescending(){
try{
System.out.println("The Descending is trying to sort the shared
buffer");
// Sort the buffer in descending order
// Call displayStatus after you sort and before release the lock
// Implement the Descending functionality in the area below

//--------------------------------------------
end of Descending function
System.out.println("Problem with the Descending function "+e.t
oString());
}
}
buffer[i]=1+newRandom().nextInt(9);//random value be
tween 1 and 10
}
@Override

publicvoid run(){
while(true){
try{
Ascending();//sort in ascending order the shared buffer
tween 200 and 500
}
}
}
});
@Override
publicvoid run(){
while(true){
try{
Descending();//sort in ascending order the shared buffer
tween 200 and 500
}
}
}
});

thread1.setName("ascending");
thread1.start();
thread2.setName("descending");
thread2.start();
}
}
__MACOSX/._Question3_SortingArrays.java
Question2_ProducerConsumer.javaQuestion2_ProducerConsume
r.javapackageThreads_Synchronization;
import java.util.Random;
publicclassQuestion2_ProducerConsumer{
/*
* In this question use mutex lock(s) to enable process synchr
onization
*
* Thread 1 and thread 2 share a single buffer (1D Array), wh
ere:
* thread 1 adds item to the shared buffer only if there is a fr
ee space
* thread 2 consumes item from the shared buffer only if ther

e is an available item in the buffer
*
*/
// DONOT CHANGE THESE VARIABLE
publicstaticintBufferSize=5;//the size of the buffer
publicstaticint count =0;//keeps track of the number of items cur
rently in buffer
publicstaticint buffer[]=newint[BufferSize];//the buffer to add d
ata into and consume data from
// add below any further resources you think the producer and c
onsumer functions must share
//--------------------------------------------
// this function simply displays the content of the shared buffer
and which thread made the call
if(Thread.currentThread().getName().equals("producer"))

System.out.println("Producer successfully added the new item t
o the shared buffer");
else
System.out.println("Consumer successfully removed an item fro
m the shared buffer");
System.out.print(" the "+Thread.currentThread().getName()+" is
displaying the content of the buffer: ");
System.out.print(buffer[i]+" ");
}
System.out.println(" and the value of the count is "+ count);
}
// this function accepts an input integer item to be added to the s
hared buffer
publicstaticvoidProducer(int item){
try{
System.out.println("The Producer is trying to add the new item
("+ item +") to the shared buffer");
// Add the input item only if there is a free space in the shared b
uffer
// Producer waits until this condition is true, thus use while rath
er than if statements
// Call the displayStatus() function after you add the item and b
efore release the lock
// Implement the producer functionality in the area below

//--------------------------------------------end of Producer function
System.out.println("Problem with the producer function "+e.toS
tring());
}
}
// this function removes an item from the shared buffer
publicstaticvoidConsumer(){
try{
System.out.println("The Consumer is trying to consume the read
y item from the buffer");
// Consume one item (overwrite its value with -
1) from the buffer only if there is an available item in the buffer
// Consumer waits until this condition is true, thus use while rat
her than if statements
// Call the displayStatus() function after you remove the item an
d before release the lock
// Implement the consumer functionality in the area below

//--------------------------------------------
end of Consumer function
System.out.println("Problem with the consumer function "+e.to
String());
}
}
count =0;
buffer[i]=-1;//free spots
}

@Override
publicvoid run(){
while(true){
try{
Producer(1+newRandom().nextInt(9));//random value between 1
and 10
tween 200 and 500
}
}
}
});
@Override
publicvoid run(){
while(true){
try{
Consumer();
tween 200 and 500
}

}
}
});
thread1.setName("producer");
thread1.start();
thread2.setName("consumer");
thread2.start();
}
}
__MACOSX/._Question2_ProducerConsumer.java
P3_MutexLocks.javaP3_MutexLocks.javapackageThreads_Sync
hronization;
publicclassP3_MutexLocks{
/*
Important to note:
Mutex Lock in literature uses acquire() and release()
in Java these functions are lock() and unlock() r
espectively
Semaphore in literature uses wait() and signal()
in Java these functions are acquire() and release(
) respectively
*/

publicstaticLock lock =newReentrantLock();//mutex lock
publicstaticint count =0;//shared variable
try{
lock.lock();
ical section");
//critical section
count++;
System.out.println("function 1 updated the count to "+ count);
lock.unlock();
System.out.println("exit the critical section ... function 1 releas
ed the lock");
}
}
}

try{
lock.lock();
ical section");
//critical section
count++;
System.out.println("function 2 updated the count to "+ count);
lock.unlock();
System.out.println("exit the critical section ... function 2 releas
ed the lock");
}
}
}
@Override
publicvoid run(){
function1();
}
});

@Override
publicvoid run(){
function2();
}
});
thread1.start();
thread2.start();
}
}
__MACOSX/._P3_MutexLocks.java
Operating System - Assignment II
Mutex locks and semaphores, as discussed in class, are different
techniques to solve the race condition and
to ensure an efficient synchronization between cooperating
threads and processes. In this assignment, you
will use locks and semaphores to solve several synchronization
problems between cooperating threads. You
can develop the required work either on your computer or on the
Ubuntu VM you installed, and you can
use any Java IDE you find appropriate (e.g., NetBeans, Eclipse,
IntelliJ). Follow the video posted on D2L;
in this video, you will create a new Java program and package
before you copy a number of .java files to
your project. This video shows how to use mutex lock and
semaphore between cooperating threads. As
discussed and shown in the video, it is important to note that:

• Mutex Lock, in literature, uses acquire() and release().
However, in the standard library of Java, these
functions are lock() and unlock(), respectively. The same
functionalities but with different names.
• Semaphore, in literature, uses wait() and signal(). However, in
the standard library of Java, these functions
are acquire() and release(), respectively. The same
functionalities but with different names.
Task description:
The files (named question1, question2, and question3) are for
three different synchronization problems,
with a full Java skeleton. The comments in the Java files
explain in detail the required functionalities and
guide you to where exactly you should place your
implementation, read them carefully before starting
coding. DO NOT CHANGE any already existing code (e.g.,
function name, variable name).
• In the first question, the deposit and withdraw functions share
a bank account to add a certain amount or
subtract a certain amount from the balance, respectively. Use
semaphore(s) to implement the
synchronization.
•
• In the second question, the producer and consumer functions
share an array of integer values to add items
or remove items from the buffer, respectively. Use mutex
lock(s) to implement the synchronization.
•

• In the third question, the Ascending and Descending functions
share an array of integer values to sort
them in ascending or descending order, respectively. Use either
mutex lock(s) or semaphore(s) to
implement the synchronization. Implement the sorting method
you find appropriate (e.g., selection sort,
bubble sort, insertion sort), but don’t use collection
methods/APIs (e.g., Arrays.sort).
Note: the threads running the above questions are implemented
to run in an infinite loop, so at some
point, you may need to force-stop the program.
Submission:
1. This is an individual assignment -- Cheating/plagiarism will
be checked and will receive zero.
2. Your submission to the folder titled Assignment 2 under the
D2L Assignments tab contains the following:
a. The three java files you worked on
b. One Runtime.pdf: - For each of the three java files, copy the
full java code and add a
clear screenshot of the output after running the code.
* these are separate files within your submission, don’t submit a
zip file
3. The assignment is due October 21st – 11:59pm. You can
submit your assignment within 24 hours
after this due date to be graded out of 50% of the assignment’s

grade. After this grace period, your
late submission will not be accepted.
· Identify a personal project of your choosing. This could be a
family vacation, plans to clean or organize a part of your living
space, etc.
· For the discussion, you will use the tools provided in Chapter
4 of your textbook to provide a brief summary of your project
that includes the scope of the project and at least three goals or
objectives of the project.

Chapter FourDefining the Project© 2021 McGraw Hill. All ri.docx

Recommended

Recommended

More Related Content

Similar to Chapter FourDefining the Project© 2021 McGraw Hill. All ri.docx

Similar to Chapter FourDefining the Project© 2021 McGraw Hill. All ri.docx (20)

More from bartholomeocoombs

More from bartholomeocoombs (20)

Recently uploaded

Recently uploaded (20)

Chapter FourDefining the Project© 2021 McGraw Hill. All ri.docx