Principles of Software Engineering

Software Engineering

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



George Polya outlined the essence of problem solving

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

Same thing is expressed by Deming as PDCA - explained better plan, do, check and adjust.

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 to something 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. (Management topic)

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.  (Quality management)
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.  (Industrial Engineering - Human Effort Industrial Engineering).
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 iteratively. 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. (Programming productivity - Industrial Engineering).
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 you'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

Improving testing is part of process improvement steps of Industrial Engineering (Operation Process Chart - Flow Process Chart)

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.

Seven basic principles of software engineering

Barry W.Boehm, 1983

A small set of basic principles. These seven principles form a reasonably complete set. These are:

(1) manage using a phased life-cycle plan.

(2) perform continuous validation.

(3) maintain disciplined product control.

(4) use modern programming practices.

(5) maintain clear accountability for results.

(6) use better and fewer people. (Industrial Engineering)

(7) maintain a commitment to improve the process.

The paper provides rationale behind this set of principles is discussed.  

Journal of Systems and Software

Volume 3, Issue 1, March 1983, Pages 3-24

https://www.sciencedirect.com/science/article/abs/pii/0164121283900031

SOLID - Five design principles in object-oriented computer programming

The principles are a subset of many principles promoted by American software engineer and instructor Robert C. Martin in his 2000 paper Design Principles and Design Patterns.

The SOLID concepts are

The Single-responsibility principle: "There should never be more than one reason for a class to change." In other words, every class should have only one responsibility.

The Open–closed principle: "Software entities ... should be open for extension, but closed for modification."

The Liskov substitution principle: "Functions that use pointers or references to base classes must be able to use objects of derived classes without knowing it".

The Interface segregation principle: "Many client-specific interfaces are better than one general-purpose interface."

The Dependency inversion principle: "Depend upon abstractions, [not] concretions."

The SOLID acronym and set of principles was formulated by Michael Feathers in 2004.

https://en.wikipedia.org/wiki/SOLID

Principles of Green Software Engineering

Green Software Engineering is an emerging discipline. It is based on climate science, software practices and architecture, electricity markets, hardware and data center design.

The Principles are to be used to define, build and run green sustainable software applications.

Carbon: Build applications that are carbon efficient.

Electricity: Build applications that are energy efficient.

Carbon Intensity: Consume electricity with the lowest carbon intensity.

Embodied Carbon: Build applications that are hardware efficient.

Energy Proportionality: Maximize the energy efficiency of hardware.

Networking: Reduce the amount of data and distance it must travel across the network.

Demand Shaping: Build carbon-aware applications.

Measurement & Optimization: Focus on step-by-step optimizations that increase the overall carbon efficiency.

Asim Hussain, Green Cloud Advocacy Lead at Microsoft.

https://principles.green/

Principles of Information Systems - Ralph M. Stair and George W. Reynolds

Ubiquity of Industrial Engineering Principle of  Industrial Engineering.

Engineering subjects belong to one engineering branch or other. Every #engineering branch has product design process, process design process, production process, inspection process, material handling process, storage process, equipment operating process, equipment maintenance process, equipment replacement process, equipment retirement process, reuse and recycling process.

Industrial engineers have to develop productivity science based on #productivity measurements for all engineering processes and output, do productivity engineering to improve productivity and do productivity management to plan, manage and realize productivity improvement. To do it, industrial engineers need to have the knowledge of the concerned engineering subject, process or output.

 #IndustrialEngineering

https://nraoiekc.blogspot.com/2017/06/industrial-engineering-in-all-branches.html

Updated on  21.12.2021.  9.12.2021,  1 June 2021
Pub 5 April 2015