April 5, 2015

Principles of Software Engineering

Software Engineering

Based on Book of Roger Pressman, Sixth Edition
Software Engineering Practice



George Polya outlined the essenece of problem solving

1. Understand the problem
2. Plan a solution
3. Carry out the plan
4. Examine the result for accuracy

Core Principles

the dictionary defines the word principle as "an important underlying law or assumption required in a system of thought."

David Hooker has proposed seven core principles that focus on software engineering process as a whole.

1. The reason it all exists.
2. Keep it simple, stupid
3. Maintain the vision
4. What you produce, others will consume
5. Be open to the future
6. Plan ahead for reuse.
7. Think

Communication Principles that apply to customer communication

1. Listen
2. Prepare before you communicate
3. Someone should facilitate the activity
4. face to face communication is best.
5. Take notes and document decisions
6. Strive for collaboration
7. Stay focused, modularize your discussion.
8. If something is unclear, draw a picture
9. Once you agree to something move on; If you can't agree tosomething move on; If a feature or function is unclear and cannot be clarified at the moment, move on.
10. Negotiation is not a contest or a game. It works best when both parties win.

Principles of Planning

1. Understand the scope of the project
2. Involve the customer in the planning activity
3. Recognize that planning is iterative
4. Estimate based on what you know.
5. Consider risk as you define the plan
6. Be realistic
7. Adjust granularity as you define the plan
8. Define how you intend to ensure quality.
9. Describe how you intend to accommodate change
10. Track the plan frequently and make adjustments as required.


Analysis Modeling Principles

1. The information domain of a problem must be represented and understood.
2. The functions that the software performs must be defined.
3. The behavior of the software (as a consequence of external events) must be represented.
4. the models that depict information, function, and behavior must be partitioned in a manner that uncovers detail in a layered(or hierarchical) fashion.
5. The analysis task should move from essential information toward implementation detail.

Software Design Modeling Principles

1 Design should be traceable to the analysis model.
2. Always consider architecture of the system to be built.
3. Design of data is as important as design of processing function
4. Interfaces must be designed with care (both external and internal)
5. User interface design should be designed to the needs of the end 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 representations (models) should be easily understandable.
9. The design should be developed iternatively. With each iteration the designer should strive for greater simplicity.


Coding Principles and  Concepts

Preparation Principles

1. Understand the problem you're trying to solve.
2. Understand the basic design principles and concepts.
3. Pick a programming language that meets the needs of the software to be built and the environment in which it will operate.
4. Select a programming environment that provides tools that will  make your work easier.
5. Create a set of unit tests that will be applied once the component you code is completed.


Coding Principles

1. Constrain your algorithms by following structured programming (BOH00)
2. Select data structures that will meet the needs of the design.
Understand the software architecture and create interfaces that are consistent with it.
4. Keep conditional logic as simple as possible.
5. create nested loops in a way that makes them easily testable.
6. Select meaningful variable names and follow other local coding standards
7. Write code that is self-documenting.
8. Create visual layout (e.g., indentation and blank lines) that aids understanding.


Validation Principles

1. Conduct a code walkthrough when appropriate.
2. Perform unit tests and correct errors yoou've uncovered.
3. Refactor the code.

Software Testing Principles


Principles developed by Davis
1. All tests should be traceable to customer requirements.
2. tests should be planned long before testing begins.
3. The pareto principle applies to software testing.
4. testing should begin "in the small" and progress toward testing "in the large"
5. Exhaustive testing is not possible


Deployment Principles

1. Customer expectations for the software must be managed.
2. A complete delivery package must be assembled and tested.
3. A support regime must be established before the software is delivered.
4. Appropriate instructional materials must be provided to end users.
5. Buggy software should be fixed first, delivered later.





1 comment:

  1. 70 principles are there in the post on 31 July 2016 before modifications

    ReplyDelete