Design Concepts in Software Engineering: Types & Examples – Video & Lesson Transcript

The core design concepts in software engineering should be followed to create a successful program or application. This lesson will go through those main design concepts and explain how each one plays a role in software development.

In the field of software development, there are many stages of planning and analysis before the project is finalized and development can formally begin. Design always comes before development, and functional design makes coding and maintenance very simple.

There are seven main principles to keep in mind in the design model in object-oriented programming (OOP):

  • Abstraction
  • Patterns
  • Separation of data
  • Modularity
  • Data hiding
  • Functional independence
  • Refactoring

Each of these is an essential part of the design model and must be met if one wishes to develop a successful software system. Each principle must be considered and thoroughly reviewed before the testing phase of the software can begin.

Abstraction & Patterns

Our first principle, abstraction, is the process of hiding complex properties or characteristics from the software itself to keep things more simplistic. This allows for a much higher level of efficiency for complex software designs since it allows the developers to list out only the necessary elements or objects required. In this principle, the developer will define the properties, type of functions, and the interface for each of said objects in the project. The developers will be able to hide the complicated and unnecessary details in the background while retaining core information in the foreground.

We use patterns to identify solutions to design problems that are recurring and can be solved reliably. A pattern must be guaranteed to work so that it may be reused many times over, but it also must be relevant to the current project at the same time. If the said pattern does not fit into the overall design function of the current project, it might be possible to reuse it as a guide to help create a new pattern that would be more fitting to the situation.

There are three main patterns:

  • Architectural, which is a high-level pattern type that can be defined as the overall formation and organization of the software system itself.
  • Design, which is a medium-level pattern type that is used by the developers to solve problems in the design stage of development. It can also affect how objects or components interact with one another.
  • And, finally, idioms, which are low-level pattern types, often known as coding patterns, and are used as a workaround means of setting up and defining how components will be interacting with the software itself without being dependent on the programming language. There are many different programming languages all with different syntax rules, making this a requirement to function on a variety of platforms.

Separation of Data & Modularity

Known as separation of concerns, this principle states that the software code must be separated into two sections called layers and components. To ensure proper implementation, the two sections must have little to no overlap between them and must have a defined purpose for each component. This principle allows each component to be developed, maintained, and reused independently of one another. This eases the development stage and benefits future updates of software since it allows the code to be modified without needing to know the specifics of other components.

Modularity, on the other hand, refers to the idea of using predetermined code to increase overall efficiency and management of the current project. The software components will usually be divided into unique items known as modules. Their specific functions divide these modules. Modularity makes the systems easy to manage.

Hiding, Independence, & Refactoring

Also known as information hiding, data hiding allows modules to pass only the required information between themselves without sharing the internal structures and processing. The specific purpose of hiding the internal details of individual objects has several benefits. Increased efficiency, in general, allows for a much lower level of error while ensuring high-quality software. It’s important to note that data hiding only hides class data components.

Unlock Content

Over 79,000 lessons in all major subjects

Get access risk-free for 30 days,
just create an account.

Try it now

No obligation, cancel anytime.

Want to learn more?

Select a subject to preview related courses:

To unlock this lesson you must be a Member.
Create your account