Chapter 5 - Practice: A Generic View
Terms in this set (29)
Describe professional practice
the concepts, principles, methods, and tools used by software engineers and managers to plan and develop software
Describe the distinctions between a software process and a professional practice
a software process provides the project stakeholders with a roadmap to build quality products; a professional practice provides software engineers with the details needed to travel the road.
encompasses the technical activities needed to produce the work products defined by the software process model chosen for a project.
Software Engineering Process Framework Activities
Communication (developer stakeholder collaboration)
Modeling (requirements and design)
Construction (code generation and testing)
Deployment (customer provides feedback on delivered products)
Software Engineering Process Umbrella Activities
Software project tracking and control
Software quality assurance
Formal technical reviews
Software configuration management
Work product preparation and production
Essence of Practice
Understand the problem (communication and analysis)
Plan a solution (software design)
Carry out the plan (code generation)
Examine the result for accuracy (testing and quality assurance)
Issues involved in "Understanding the Problem"
Who are the stakeholders?
What functions and features are required to solve the problem?
Is it possible to create smaller problems that are easier to understand?
Can a graphic analysis model be created?
Issues involved in "Planning the Solution"
Have you seen similar problems before?
Has a similar problem been solved?
Can readily solvable subproblems be defined?
Can a design model be created?
Issues involved in "Carry Out the Plan"
Does solution conform to the plan?
Is each solution component provably correct?
Issues involved in "Examine the Result"
Is it possible to test each component part of the solution?
Does the solution produce results that conform to the data, functions, and features required?
Software Practice Core Principles
1. Software exists to provide value to its users
2. Keep it simple stupid (KISS)
3. Clear vision is essential to the success of any software project
4. Always specify, design, and implement knowing that someone else will have to understand what you have done to carry out his or her tasks
5. Be open to future changes, don't code yourself into a corner
6. Planning ahead for reuse reduces the cost and increases the value of both the reusable components and the systems that require them
7. Placing clear complete thought before any action almost always produces better results
Principles of Effective Communication
Prepare before you communicate
Have a facilitator for any communication meeting
Face-to-face communication is best
Take notes and document decisions
Strive for collaboration
Stay focused and modularize your discussion
Draw a picture if something is unclear
Move on once you agree, move on when you can't agree, Move on if something unclear can't be clarified at the moment
Negotiation is not a contest or game
Goals for Communication
Identify the customer and other stakeholders
Establish an effective mode of communication between developers and stakeholders
Develop usage scenarios
Generic Task Set for Communication
1. Identify primary customer and other stakeholders
2. Meet with customer to define business needs and values, end-user characteristics and needs, required outputs, and business constraints
3. Develop one page written statement of project scope
4. Review statement of scope with stakeholder and revise as needed
5. Collaborate with customer/end-users to define usage scenarios, input, outputs, software features and functions, customer business risks
6. Develop written descriptions of user scenarios, inputs, outputs, features, functions, and risks
7. Iterate with customer to define priorities for user scenarios, features, functions, and risks
8. Assign customer defined priorities to each user scenario, feature, and function
9. Review all information gathered with customers and other stakeholders
10. Prepare for planning activity
1. Understand scope of project
2. Involve customer in planning activities
3. Recognize that planning is iterative
4. Make estimates based on what you know
5. Consider risk as you define the plan
6. Adjust the granularity as you define the plan
7. Define how you will measure quality
8. Describe how you will accommodate change
9. Track the plan frequently and make adjustments as needed
Boehm's W5HH Principle
1. Why is the system being developed?
2. What will be done?
3. When will it be accomplished?
4. Who is responsible for a function?
5. Where will they organizationally be located?
6. How will the job be done technically and managerially?
7. How much of each resource is needed?
Goals for Planning
1. Develop an overall project strategy
2. Identify the functionality to be delivered by each software increment
3. Develop a detailed plan for the current iteration
4. Track progress of a regular basis
Generic Task Set for Planning
1. Re-evaluate project scope
2. Assess risks
3. Develop/refine user scenarios
4. Extract functions and features from scenarios
5. Define technical functions and features needed for software infrastructure
6. Group functions and features according to customer priorities
7. Create a low granularity project plan
8. Create high granularity plan for current iteration
9. Track progress regularly
Analysis Modeling Principles
1. The information domain for the problem must be represented and understood
2. Functions performed by the software must be defined
3. Software behavior must be represented as consequences of external events
4. Models depicting the information, function, and behavior must be partitioned in manner that uncovers detail in a hierarchical fashion
5. The analysis task should move from essential information toward implementation detail
Generic Goals for Modeling
1. Review requirements and constraints
2. Expand and refine user scenarios
3. Model information domain
4. Define analysis classes using information objects as a guide
5. Represent responsibilities and collaborations of each analysis class
6. Group related classes into packages
7. Model functional domain
8. Model behavioral domain
9. Analyze and model the user interface
Design Modeling Principles
1. Design should be traceable to the analysis model
2. Always consider the architecture of the system to be built
3. Data design is as important as algorithm design
4. Internal and external interfaces must be designed with care
5. User interface design should be tuned to the needs of the end-user and must focus on use of user
6. Component-level design should be functionally independent
7. Components should be loosely coupled to one another and to the external environment
8. Design models should be easy to understand
9. Design should be developed iteratively
Generic Task Set for Design
1. Using the analysis model select an architectural style appropriate to the software
2. Partition analysis model into subsystems and allocate subsystems within the architecture
3. Examine the information domain model and design appropriate data structures for data objects and their attributes
4. Create a set of design classes
5. Design User interface
6. Conduct component-level design
7. Develop deployment model
Agile Modeling Principles
1. Primary goal of the software team is to build software not create models
2. Don't create any more models than you have to
3. Strive to produce the simplest model that will describe the problem or software
4. Build models in a way that makes them amenable to change
5. Be able to state the explicit purpose for each model created
6. Adapt models to the system at hand
7. Try to build useful models, forget about trying to build perfect models
8. Don't be dogmatic about model syntax as long as the model communicates content successfully
9. If your instincts tell you there is something wrong with the model then you probably have a reason to be concerned
Get feedback as soon as you can
Before writing any code be sure you:
- Understand problem to solve
- Understand basic design principles
- Pick a programming language that meets the needs of the software to be built and the environment
- Select a programming environment that contains the right tools
- Create a set of unit tests to be applied once your code is completed
As you begin writing code be sure you:
- Use structured programming practices
- Select data structures that meet the needs of the design
- Understand software architecture and create interfaces consistent with the architecture
- Keep conditional logic as simple as possible
- Create nested loops in a way that allows them to be testable
- Select meaningful variable names consistent with local standards
- Write code that is self-documenting
- Use a visual layout for you code that aids understanding
After your complete your first coding pass be sure you:
- Conduct a code walkthrough when appropriate
- Perform unit tests and correct uncovered errors
- Refactor the code
1. Testing is the process of executing a program with the intent of finding an error
2. A good test is one that has a high probability of finding an undiscovered error
3. A successful test is one that uncovers an undiscovered error
- All tests should be traceable to customer requirements. Note: White-box tests are traceable only indirectly.
- Tests should be planned long before testing begins
- Testing Pareto Principle (80% of errors are found in 20% of code)
- Testing should begin "in the small" and progress toward testing "in the large"
- Exhaustive testing is not possible
Generic Task Set for Construction
- Build the architectural infrastructure
- Build a software component
- Unit test the component
- Integrate completed component into architectural infrastructure
- Customer software expectations must be managed
- Complete delivery package should be assembled and tested
- Support regime must be established before software is delivered
- Appropriate instructional materials must be supplied to end-users
- Buggy software should be fixed before it is delivered
Generic Task Set for Deployment
Create delivery media
Establish the human support person(s)
Establish user feedback mechanisms
Disseminate delivery media to all users
Conduct on-going support functions
Collect user feedback