Adapting Engineering Principles of Software Designing

In todays world the need for Computer Engineers and Software Engineers are growing
constantly. Engineering is the application of mathematics, empirical evidence and scientific,
economic, social, and practical knowledge in order to invent, design, build, maintain, research,
and improve structures, machines, tools, systems, components, materials, and processes. There
are numerous reasons why Engineering Principles should be incorporated in Software Design. In
this essay only five reasons will be expounded on.
The first principle which one should incorporate in Software Designing is called
Separation of Concerns (SoC). Separation of concerns is a recognition of the need for human
beings to work within a limited context. The human mind is limited to dealing with
approximately seven units of data at a time. A unit is something that a person has learned to deal
with as a whole - a single abstraction or concept (For example, concentrating on a single part of a
software/program). Although human capacity for forming abstractions/ideas appears to be
infinite, it takes time and repetitive use for an abstraction to become a useful tool; that is, to serve
as a unit. Separation of concerns is important in simplifying development and maintenance of
computer programs. When concerns are well-separated, individual sections can be reused, as
well as developed and updated independently. In addition to that it gives the engineer the ability
to later improve or modify one section of code without having to know the details of other
sections, and without having to make corresponding changes to those sections.
Another principle which one should adapt is Modularity. The principle of modularity is a
specialization of the principle of separation of concerns. In software engineering, as the name
suggests, modularity refers to the extent to which a software/application may be divided into

smaller modules. Software modularity indicates that the number of application modules are
capable of serving a specified business domain. Modularity is successful because
developers/engineers use prewritten code, which saves resources. Modularity provides greater
software development manageability.
The principle of abstraction is another specialization of the principle of separation of
concerns. The principle of abstraction implies separating the behavior of software components
from their implementation. It requires learning to look at software and software components
from two points of view: what it does, and how it does it. Furthermore, Abstraction is an
identical application, where the implementation of a particular interface is separated from its
design. The interface can be a data structure or a framework. An API, for example, is literally an
application programming interface, providing a deeper discussion of the relations among types,
data abstraction, and polymorphism (occurring in different forms). Abstraction in computer
programming is an evolution that resulted out of the necessity of reducing complexity for users
as well as software engineers and to quantify and to simplify new applications of existing
paradigms. The iteration to this new style provides a technique for programming and a way to
write good programs to solve a given problem in an organized, portable, and reusable way.
In addition to Abstraction, one should always be Consistent. The principle of Consistency
is a recognition of the fact that it is easier to do things in a familiar context. For example, 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.
Also, the anticipation of change should be incorporated in Software Engineering. When
there are changes, additional costs will be incurred. A design goal in software development is to

ensure cost is kept to a minimum. One approach is to anticipate where changes are likely to
occur and make provisions for the changes during the design stage. One need to provide tools for
storing and retrieving documents, and for managing source code and object code. These tools
must also be worked into the overall configuration management of a system.
In concluding, engineering techniques should be incorporated in software engineering as
they prove to make software designing easier, efficient and affordable.

Bibliography
Work Cited
Principles of Software Engineering. d.umn.edu. Web.
https://www.d.umn.edu/~gshute/softeng/principles.html
Seven Strategies for Successful Software Engineering: Part 3 BrightHub.com Web. 10 July
2008.
http://www.brighthub.com/computing/windows-platform/articles/10178.aspx
Separation of Concerns Wikipedia.com Web. 21 October 2015.
https://en.wikipedia.org/wiki/Separation_of_concerns