SOFTWARE ENGINEERING PRINCIPLES:
Separation of Concerns:
In software engineering, the partition of concerns (SoC) is an outlined guideline for isolating a PC program into areas, to such an extent that each segment tends to have a different concern. A concern is the arrangement of data that influences the code of a PC program.
Modularity:
The principle of modularity is a specialization of the guideline of separation of concerns. Following the principle of modularity infers isolating programming into segments as per usefulness and obligation.
Abstraction:
The principle of abstraction is another specialization of the principle of separation of concerns. Following the principle of abstraction infers isolating the conduct of programming segments from their usage. It expects figuring out how to take a gander at programming and programming parts from two perspectives: what it does, and how it does it.
The inability to isolate conduct from execution is a typical reason for pointless coupling. For instance, usually in recursive calculations to acquaint additional parameters to make the recursion work. At the point when this is done, the recursion ought to be called through a non-recursive shell that gives the best possible beginning qualities to the additional parameters. Otherwise, the guest must manage a more mind-boggling conduct that requires determining the additional parameters. If the execution is later changed over to a non-recursive algorithm, then the customer code will likewise be changed.
Anticipation of Change:
Requirements of change by the customer are unavoidable during the development and maintenance of software. To reduce any negative impact of change, make it happen as soon as the requirement arises during the development so that changes made can cope with the rest of the system. The developer should identify expected changes and plan for change before the requirement. Maintenance is a continuous process of error elimination and modifications. Regression testing is also essential during the maintenance of software if some error occurs suddenly.
Generality:
This principle is very much related to the principle of anticipation of change. While designing software a developer should keep in view that it should be free from any unusual limitations. For example, the software will get distorted if it will have a limitation of entering a year after a century completes the “the year 2000” problem which occurred in much software made before. A developer should keep in mind if he/she is producing good quality software it should survive more than its expected lifetime.
Incremental Development:
Incremental development is where the product is incrementally designed, applied, and tested during development or maintenance. The incremental process of development makes verification very easy as you add functions in small increments which are easily testable in portions. Portions are isolated, and that’s why errors can be easily rectified. Portions most likely to change should be kept at the end of the development procedure so that amendments could be made easily.
Consistency:
This principle plays a vital role in software development, particularly for the developer during the process. It saves the time of the developer so that he/she could focus on other important issues. If the developer types code consistently, it becomes easily readable and makes it easy to copy if the same code is required again at some place in the development, relieving the developer from typing the iterating code again.
The principle of consistency is a recognition of the fact that it is easier to do things in a familiar context. For example, the coding style is a consistent manner of laying out code text. This serves two purposes. First, it makes reading the code easier. Second, it allows programmers to automate part of the skills required in code entry, freeing the programmer’s mind to deal with more important issues.
