7 Principles of Software Engineering

The key to solve any software engineering or application development problems are closely related to principles of good design and engineering. The following seven principles of design and engineering have guided me over the years to become a better web developer.

For any developer or software engineer out there who have never try to practicing any engineering principles, I believe this can be the key that will guide you to become a better software developer or engineer. This principles will help you with a more efficient way to solve problems and to produce code which is easier to maintain and that has fewer defects, less frustration and less headache.



Secure coding is the practice of writing programs that are resistant to attack by malicious or mischievous people or programs. Secure coding helps protect a user’s data from theft or corruption. In addition, an insecure program can provide access for an attacker to take control of a server or a user’s computer, resulting in anything from a denial of service to a single user to the compromise of secrets, loss of service, or damage to the systems of thousands of users. For the best Secure coding practice every developer needs to create an application architecture and design your application to implement and enforce security policies.

Applications without security architecture are as bridges constructed without finite element analysis and wind tunnel testing. Sure, they look like bridges, but they will fall down at the first flutter of a butterfly’s wings. The need for application security in the form of security architecture is every bit as great as in building or bridge construction.

Developers are responsible for constructing their application to adequately cover risks from both typical usage, and from extreme attack. Bridge designers need to cope with a certain amount of cars and foot traffic but also cyclonic winds, earthquake, fire, traffic incidents, and flooding. Developers must cope with extreme events, such as brute force or injection attacks, and fraud. The risks for application designers are well known. The days of “we didn’t know” are long gone. Security is now expected, not an expensive add-on or simply left out.

Security architecture refers to the fundamental pillars: the application must provide controls to protect the confidentiality of information, integrity of data, and provide access to the data when it is required (availability) – and only to the right users. Security architecture is not “markitecture”, where a cornucopia of security products are tossed together and called a “solution”, but a carefully considered set of features, controls, safer processes, and default security posture.



One of the thing that every end users hate so much when using a software is when they are forced to wait for the application to load. When the application load really slow this can become a big issue, especially for a business process that depends heavily on the performance of the application in supporting it. This may lead to potential loss of trade and customers.

Here comes the efficiency part, code efficiency means the reliability of an application in terms of providing speed and performance assistance. Code efficiency is directly linked with algorithmic efficiency and the speed of runtime execution for software. It is the key element in ensuring high performance.

The goal of code efficiency is to reduce resource consumption and completion time as much as possible with minimum risk to the business or operating environment. The software product quality can be accessed and evaluated with the help of the efficiency of the code used.

Code efficiency plays a significant role in a high-execution-speed environment where performance and scalability are paramount to the application. Well-developed programming codes should be able to handle complex algorithms.



Code consistency refers to the standards of writing the code which will be dependent on various factors like readability, compliance with architecture, etc. Consistency in writing the codes helps other developers to read and understand the meaning of the codes. It lets them know what to expect. If he names constants with SCREAMING_SNAKE_CASE, they know that they won’t change.

It also ensures that other developers will be free of headache if using the codes as a library in their projects. A developer will never used inconsistence codes as a library for their projects. Imagine that everytime the codes is updated there will likely be a new block of function that’s not following the naming convention which can lead to codes conflict or a change of constant that will lead to application malfunction.

When writing an application, inconsistence code can cause several difficulties in maintaining the application itself. It’s like an unstable old crappy car that will stop working at any moment. If the codes is used to build an Application Programming Interface, and there are the always changing endpoints provided by the API then there will be no one who can use it because of the inconsistency. Code consistency also gives stability in application functionalities.



Codes are collections of statements and formulas written in one or more programming language, and a language means for communication. It means, codes are tool means for communication. With whom? Machine? No, machine is not communicating, it executing the codes incidentally.

The ones whom the codes are communicating with are none other than the developer itself and the people that’re trying to figure out about their existence. Other people and yourself in the future will have to interpret what you were thinking when you go to fix a bug in your application. You have to get familiar with your thought process to figure out how to not only update your code but to also make sure that it doesn’t break.

The definitions of the clarity itself is clearness or lucidity as to perception or understanding; freedom from indistinctness or ambiguity. It’s a way to provide peace-of-mind to the developers while also help them understanding each other intentions of what they want to accomplish. That’s why clarity in programming is so important.



Don’t Repeat Yourself (DRY) is the fundamental principle in software and application development. Reusability is the use of existing assets in some form within the software product development process. Assets are products and by-products of the software development life cycle and include code, software components, test suites, designs and documentation.

Subroutines, methods and functions are the simplest form of the code reusability. A chunk of code is regularly organized using modules or namespaces into layers. The ability to reuse relies in an essential way on the ability to build larger things from smaller parts and being able to identify commonalities among those parts.

When this principle is applied successfully, a modification of any single element of a software does not require a change in other logically unrelated elements. Additionally, elements that are logically related all change predictably and uniformly, and are thus kept in sync. Reusability wil help developers to maintain a complexity of the codes especially when working on large projects.



Many developers think that extensibility is the about the application scalability. Well, they are wrong. It’s neither about capacity nor volume. Extensibility is about the vision of the developer for the future, it’s a concept where the developer take the future growth of the application into consideration by giving the application an ability to have additional features or extensions.

Extensions can be implemented through the addition of new functionality or through modification of existing codes to improve the functionality. Application that’s built with extensibility in mind reduce unncessaries frustations in the future because an extensible application means one that you can extend without modifying its original code base.

An application that is not extensible will work against developer from making even simple upgrades and changes to the way the application works. An application that’s built without an ability to add a new functionality will have no future growth and results in a big waste of time, money, and resources. Because not everything can built in advance, a future vision and plan is required for a long lasting application.



KISS (Keep It Simple, Stupid!). is design principle that states that most systems work best if they are kept simple rather than made complicated; therefore simplicity should be a key goal in design and unnecessary complexity should be avoided.

KISS is not meant to imply stupidity, It means that you should strive for the simplest way of doing something. KISS is also an acronym for “keep it short and simple” and “keep it simple and straighforward”. Kelly Johnson formulated the KISS principle in the mid-1900s while working as an engineer for the Lockheed Skunk Works, Lockheed Martin’s advanced aircraft development program.

Occam’s (or Ockham’s) Razor: A 14th century theory that states that in a series of hypotheses, the simplest one is most likely to be correct unless the burden of proof rests on a more complicated theory.

There are similar concepts in many areas. In software development designing and developing an application is not a haphazard process. There are many factors to consider in any design effort. All design should be as simple as possible, but no simpler. This facilitates having a more easily understood, and easily maintained system.

That is not to say that features, even internal features, should be discarded in the name of simplicity. Indeed, the more elegant designs are usually the more simple ones. Simple also does not mean “quick and dirty.” In fact, it often takes a lot of thought and work over multiple iterations to simplify. The payoff is software that is more maintainable and less error-prone.



When designing and developing software or applications, its always all about finding and applying the best ways to solve technical problems. The software engineers or application developers must figure out what is the solution for each of the problems that requires creative problem solving.

Because of the inherent creativity required to solve software problems, the source code of multiple engineers or developers building the “same” thing will probably look very different. Despite this, if they stick to established principles, patterns, designs and methods to do so, then they will all likely arrive at similarly effective solutions and will have accomplished the task at hand.

These seven principles, patterns, designs, and methods are a way for producing good software or application. Many were inherited from other area of expertise disciplines while others are hard won epiphanies from years in the trenches of building software. We are not here to remember all these principles but to absorb what it means to engineer and how is the engineering “works”.