Concepts and Terms that Every Software Engineer Needs to Know

Conceptual integrity, cohesion, abstract data type, coupling, information hiding, rule of least astonishment, and more

If you’ve read a technical book (I suppose you would have as a software engineer), you may have found a term or a concept that you are unfamiliar with. Perhaps you studied it at some point at college but your memory of it has faded, or maybe it’s a new one that you’ve never come across before. Usually, this depends on how advanced the book that you’re reading is, and what type of experience you need to have to get the most of your reading.

To help increase your understanding of terms and concepts (and in so doing, improve your ability to progress), I created a list of the key terms and concepts that I believe every software engineer should know. Even if you are familiar with what appears on this list, it’s always a helpful exercise to refresh your memory from time to time.

The List

Abstraction

In object-oriented programming, abstraction is the act of simplifying a real-world entity into its essential and most needed attributes and behavior in the context of the software purpose. So, in the context of a government application, a user object needs to have (firstName, lastName, nationalIdNumber); however, in an e-commerce context, a user object doesn’t need the attribute “nationalIdNumber”.

Attribute

An object attribute is a property (variable) that holds different values depending on the object status. For example, say there are two user objects, one can have the attribute/property firstName=” Mohamad” while the second has firstName=”John”.

Behaviors

Object behavior is an action that the object can perform. For example, a user object may have the behavior of getting a user’s full name.

Encapsulation

Encapsulation involves bundling the necessary attributes and behavior in one class. It exposes only features that other objects need and hides the rest. In the user object, it doesn’t make any sense to save the user’s shopping cart. Still, it’s ok to save their name. It will also make sense to make getFullName() a public method but make generatePasswordSalt() a private method.

Information hiding

This involves designing classes so that attributes and methods that other classes do not need are hidden from them.

Decomposition

Decomposition is breaking a big or whole entity into simpler and smaller parts where it’s easy to integrate together and form the bigger entity. For example, in the e-commerce context, a user can have a billing address and shipping address or maybe multiple shipping addresses (home, office, lake house, etc.). In this case, you will need to make the address a separate object with its own attributes and behavior.

Polymorphism

This is the ability to interact with different object types in the same way. Usually because they all inherit the same super-class or apply the same interface. Imagine you have an interface called “DataStore” that has two method signatures “query() and save()” now you can have multiple objects which implement this interface “FileSystemStorage, DBStroage, etc.”. Hence, while they are different types of objects, all of them have two methods “query() and save().”

Generalization

This involves refactoring common attributes and methods in a separate class where it can be reused more often. It will ensure your system is less coupled.

Coupling

This is a term in software engineering that describes when two parts of a system depend on each other such that each of them can’t be reused individually in another context. This is considered bad practice because these two parts are “coupled”. Remember the address object we created earlier? You can use it with the user address or the store Address, etc. so it’s no longer coupled to the user object.

Flexibility

Flexibility refers to how easy it is to apply changes or add features to your system without breaking it.

Maintenance

This refers to fixing, improving, or changing features after system delivery.

Abstract Data Type:

This is a data type that is defined by its behavior and has no implementation. You can think of the abstract data type as a theoretical concept used in software design. An example of an abstract data type would be a stack, queue, or list. A stack must have the operations “Push and Pop”, how these operations are implemented are decided by the developer, not the programming language. This is the same for the queue data type; it must have the operations “enqueue and dequeue.” Now imagine you are a developer building a list. A list is an abstract data type whose interface is provided by the programming language and implementation done by the developer. A developer can create a linked-list or array-list or any other list.

Implementation

This is process of creating a working system out of the design. Put simply, it is the process of writing the code.

Cohesion

Cohesion describes how straightforward a module or a class purpose is. A high cohesion module means that its purpose is clear and is no more complex than it needs to be. On the other hand, a low cohesion means it’s very complicated and its purpose is not clear.

Conceptual integrity

When software has a conceptual integrity it means that there is such a strong unifying theme or feel to it that it appears as though one developer programmed it. In actual fact, an entire team may have developed the software but because they have followed the same guidelines and structure everything appears uniform.

Concern

This refers to a role or action of the part of the system. You may also hear the term “separation of concerns” which helps you in decoupling your system components.

Rule of least astonishment

This principle states that a component should behave as one would expect it to behave. For example, as a developer, if I want to disable a user account then I would expect this to be in the user module not in the financing module.

Conclusion

While there are an innumerable amount of terms and concepts that you will come across on your journey as a software engineer, I believe that those listed here amount to a strong foundation of terms and concepts that you should be familiar with. Do you have other terms that you think software engineers should know? If so, please feel free to share those with us in the comments section.

Articles you may find interested

More to Read: - Write clean code and get rid of code smells with real life examples - Advanced Coding Skills, Techniques and Ideas