Scribd
Upload
116 views5 pages

Four Key Planning Principles in Software

This chapter describes the principles that guide software engineering practices. It discusses principles for software process, practice, communication, planning, modeling, construction and testing. Some key principles include keeping software simple, planning for change and reuse, effective communication, understanding requirements, and testing software to find errors. The goal is to produce high-quality software through practices focused on the customer and building software that is maintainable, adaptable and provides value.

Uploaded by

San Lizas Airen
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
116 views5 pages

Four Key Planning Principles in Software

This chapter describes the principles that guide software engineering practices. It discusses principles for software process, practice, communication, planning, modeling, construction and testing. Some key principles include keeping software simple, planning for change and reuse, effective communication, understanding requirements, and testing software to find errors. The goal is to produce high-quality software through practices focused on the customer and building software that is maintainable, adaptable and provides value.

Uploaded by

San Lizas Airen
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd

Chapter 4 – Principles that Guide Practice

Overview

This chapter describes professional practice as the concepts, principles,


methods, and tools used by software engineers and managers to plan and
develop software. Software engineers must be concerned both with the technical
details of doing things and the things that are needed to build high-quality
computer software. Software process provides the project stakeholders with a
roadmap to build quality products. Professional practice provides software
engineers with the detail needed to travel the road. Software practice
encompasses the technical activities needed to produce the work products
defined by the software process model chosen for a project.

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 carryout 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 that Guide Process

1. Be agile
2. Focus on quality at every step
3. Be ready to adapt
4. Build an effective team
5. Establish mechanisms for communications and control
6. Manage change
7. Assess risk
8. Create work products that provide value for others

Principles that Guide Practice

1. Divide and conquer


2. Understand the use of abstraction
3. Strive for consistency
4. Focus of the transfer of information
5. Build software that exhibits effective modularity
6. Look for patterns
7. When possible, represent the problem and its solution from a number of
different perspectives
8. Remember that someone will maintain the software

Principles of Effective Communication

1. Listen
2. Prepare before you communicate
3. Have a facilitator for any communication meeting
4. Face-to-face communication is best
5. Take notes and document decisions
6. Strive for collaboration
7. Stay focused and modularize your discussion
8. Draw a picture if something is unclear
9. Move on once you agree, move on when you can’t agree, move on if
something unclear can’t be clarified at the moment
10. Negotiation is not a contest or game

Planning Principles

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. Be realistic
7. Adjust the granularity as you define the plan
8. Define how you intend to measure quality
9. Describe how you intend to accommodate change
10. Track the plan frequently and make adjustments as required

Modeling Classes

• Requirements (analysis) models – represent customer requirements by


depicting the software in three domains (information, function, behavior)
• Design models – represent characteristics of software that help practitioners
to construct s it effectively (architecture, user interface, component-level
detail)
Requirements Modeling Principles

1. Problem information domain must be represented and understood


2. Functions performed by the software must be defined
3. Software behavior must be represented as a consequence 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

Design Modeling Principles

1. Design should be traceable to the requirements 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 design with care
5. User interface design should be tuned to the needs of the end-user and must
focus on use of use
6. Component-level design should be functionally independent
7. Components should be loosely coupled to one another and to the external
environment
8. Design representations should be easy to understand
9. Design should be developed iteratively and designer should strive to simplify
design with each iteration

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
10. Get feedback as soon as you can
Construction Activities

• Coding includes
o Direct creation of programming language source code
o Automatic generation of source code using a design-like
representation of component to be built
o Automatic generation of executable code using a “fourth generation
programming language
• Testing levels
o Unit testing
o Integration testing
o Validation testing
o Acceptance testing

Coding Principles

• Preparation - before writing any code be sure you:


o Understand problem to solve
o Understand basic design principles
o Pick a programming language that meets the needs of the software to
be built and the environment
o Select a programming environment that contains the right tools
o Create a set of unit tests to be applied once your code is completed
• Coding - as you begin writing code be sure you:
o Use structured programming practices
o Consider using pairs programmimg
o Select data structures that meet the needs of the design
o Understand software architecture and create interfaces consistent with
the architecture
o Keep conditional logic as simple as possible
o Create nested loops in a way that allows them to be testable
o Select meaningful variable names consistent with local standards
o Write code that is self-documenting
o Use a visual layout for you rcode that aids understanding
• Validation - after your complete your first coding pass be sure you:
o Conduct a code walkthrough when appropriate
o Perform unit tests and correct uncovered errors
o Refactor the code

Testing Objectives

• Testing is the process of executing a program with the intent of finding an


error
• A good test is one that has a high probability of finding an undiscovered error
• A successful test is one the uncovers and undiscovered error

Testing Principles

1. All tests should be traceable to customer requirements


2. Tests should be planed long before testing begins
3. Pareto Principle applies to testing (80% of errors are found in 20% of code)
4. Testing should begin “in the small” and progress toward testing “in the large”
5. Exhaustive testing is not possible

Deployment Actions

• Delivery
• Support
• Feedback

Deployment Principles

1. Customer software expectations must be managed


2. Complete delivery package should be assembled and tested
3. Support regime must be established before software is delivered
4. Appropriate instructional materials must be supplied to end-users
5. Buggy software should be fixed before it is delivered

Common questions

Powered by AI

Coding principles emphasize structured programming and the use of meaningful variable names as means to enhance code quality and readability. They advise selecting a programming language and environment that best fit the software's needs, ensuring clarity and efficiency . Principles such as using structured programming practices, considering pair programming, and creating self-documenting code with a visual layout all contribute to easily understandable and maintainable code . These practices reduce errors and facilitate easier future modifications.

Software practice core principles emphasize providing value to users while being open to future changes, which involves planning for reuse. For example, one principle states that software should exist to provide value to its users by meeting their needs effectively . To ensure adaptability, another principle advises not coding yourself into a corner and planning ahead for reuse, reducing costs, and increasing the value of reusable components . These principles integrate user-focused development with foresight for change and modularity.

The 'divide and conquer' principle provides advantages in software development by breaking down complex problems into manageable subproblems, which can be addressed individually before being integrated into a cohesive solution . This approach simplifies problem-solving by allowing developers to focus on smaller, isolated tasks, leading to enhanced efficiency and clarity. In addition, it promotes focus, as developers can tackle issues one at a time, ensuring a thorough understanding and robust solution for each sub-component .

Agile modeling principles promote flexibility by advising teams to only create the simplest models necessary, which encourages adaptability to change without being tied down by overly complex documentation. These principles stress that models should be built with the possibility of change in mind and that they should serve a clear purpose . Additionally, seeking feedback early helps identify necessary adjustments, ensuring models remain practical and relevant throughout the development process, thus enhancing efficiency .

The principles that guide process emphasize the necessity of establishing mechanisms for communication and control, which lead to better team collaboration. For instance, effective team building is a key principle that inherently requires strong communication channels to ensure that all team members are aligned and productive . Additionally, the principle of managing change and establishing clear communication lines help in navigating the dynamics of project requirements efficiently .

Traceability in design modeling is crucial because it ensures that every element of the design can be mapped back to requirements, confirming that all aspects of customer needs are addressed. This principle helps in maintaining alignment between what is being built and the original requirements, therefore reducing the risk of scope creep and ensuring consistency throughout the project lifecycle . The traceability from requirements to design also aids in validating and verifying the design, leading to a more coherent and effective construction of the software.

Involving customers in planning activities significantly affects the success of software projects by ensuring that the development process fully aligns with the customer's vision and requirements. This involvement facilitates clearer communication and understanding of specifications, reducing the risk of misinterpretation and misalignment with user expectations . Integrating customer feedback iteratively into the planning phase allows for adjustments that can accommodate evolving needs, enhancing the likelihood of delivering a product that satisfies user demands .

Selecting an appropriate programming environment facilitates the coding process by providing tools optimized for efficient code creation, enabling developers to focus on logic and functionality rather than technical limitations . This includes having the right debuggers, code editors, and build tools that support structured coding practices and multi-level testing, ultimately contributing to the production of high-quality, efficient software . A well-chosen environment aligns with the software's requirements and streamlines the coding workflow.

Software testing principles ensure alignment with customer requirements by mandating that all tests should trace back to these requirements. This traceability ensures that each function of the software is validated against the customer's expectations, thereby minimizing the risk of discrepancies . Moreover, the practice of planning tests early in the development process helps in identifying and addressing requirement-oriented errors sooner, leading to a product that truly meets customer needs .

Incorporating testable nested loops in coding practices is important because it ensures that complex logic can be verified through unit tests. This focuses on simplifying the loop structure to allow for isolated testing of individual loop conditions, thereby reducing errors and improving the overall reliability of the software . A testable nested loop design promotes easier maintenance and readability, helping developers to quickly identify and correct logical errors during development and future revisions .

You might also like