1.4 Software Engineering Principles and Concepts

This section presents the most important principles and concept on which software engineering is built.

Principles serve as the core around which methods, procedures, plans, tools, and techniques are later built.

	Software engineering principles are general and abstract statements describing desirable properties of
	software products and processes.

	They become engineering practice and customs through methods and techniques where methods and
	techniques are packaged in a methodology and methodology can be enforced by tools.

	In the development process of a software system, the software engineer should adhere to a number of good,
	sound software engineering principles which, when followed, lead to the production of the desirable qualities
	of a software product and process.

Software quality includes maintainability, reusability, quality, reliability, performance, scalability, etc.

	These principles are particularly tightly-coupled to software development tasks of designing, building and
	deploying and maintaining reusable software components and assets.

Software engineering principles are also needed to overcome the many tough problems that SE faces.

1.4 Software Engineering Principles and Concepts

Some of these problems include:

Software development cost

Software reliability

Software maintenance

Software productivity

Software reuse (reuse of specification, module, code, documents)

The seven principles of software engineering are:

Rigor and Formality

Separation of Concerns

Modularity

		Abstraction (using a more general concept than the one that immediately comes to mind for this
		particular instance)

Anticipation of Change

1.4 Software Engineering Principles and Concepts

Generality

Incrementality

Other principles of software engineering also include:

Strict management of phase-based life cycle.

Evaluation and review for each phase in Software Life Cycle.

Rigorous product control.

Use modern design techniques.

Review for the results in every phase.

Small and high-quality of development team (Chief investigator and its team).

Improve the practice of software engineering.

In the following we describe each of the above seven principles briefly.

	Rigor and Formality are necessary for creative and systematic software systems and they increase our
	confidence in the developed system.

1.4 Software Engineering Principles and Concepts

		Rigor means that each step and each product in the software process is implemented in a sound and
		comprehensive manner with the necessary precision.

		Formality means that the software process is driven and evaluated by formal procedures and using
		mathematical laws.

	Separation of Concerns mean that during the software process the software engineer focuses on one aspect
	and temporarily disregards the others.

		In other words, the software engineer deals with the different aspects of the software process separately
		and try to isolate aspects that are less important and not strongly related to others.

		When the software engineer separates concerns he/she separates them in various ways including time,
		qualities, different views, and different parts of the system.

Modularity is the division of the complex software project into simpler pieces called modules.

The system is then called modular system.

A module is a small component unit of the complex system.

		Modular design supports application of separation of concerns where each module is developed
		separately and independently.

1.4 Software Engineering Principles and Concepts

Modular design makes the development of the software system significantly easier to understand.

		Advantages of modularity include the capability of decomposing a complex system into simpler pieces,
		the capability of composing a complex system from existing module the capability of understanding a
		system in terms of its pieces, and finally, the capability of modifying a system by modifying only a small
		number of its pieces.

	Abstraction is the identification of the important aspects of a phenomenon and ignoring its details. Abstraction
	is a special case of separation of concerns.

		Abstraction implies ignoring the details that are not so important in the correct specification of the
		system being developed.

Abstraction generates models of the proposed application.

The model can be a formal or semiformal description.

		Dealing with the model in order to analyze the system instead of the system is usually sufficient for
		analyzing the system.

	Anticipation of Change is the consideration of the evolution and upgrading requirements of the system being
	developed.

1.4 Software Engineering Principles and Concepts

This includes taking into account the future requirements of the developed system.

		For software to evolve gracefully it is necessary to anticipate how and where the changes are likely to
		occur.

		Anticipation of change requires the appropriate tools to be available to manage the various versions and
		revisions of the software in a controlled manner.

Generality is trying to discover if the problem being solved is an instance of a more general problem.

		Sometimes a general problem is easier to solve than a special case. This enables the software engineer
		to reuse the solution of the more general system in the problem which the problem being solved.

A software engineer needs to balance the generality against performance and cost.

Incrementality is that the software process proceeds in a stepwise fashion i.e. it increments.

		This includes the delivery of subsets of a system early to get early feedback from expected users, then
		adding new features incrementally, dealing first with functionality, then turning to performance and
		delivery of a first prototype and then incrementally adding effort to turn prototype into product.