Software Engineering Principles and Practices (Work in progress)

Software Engineering

According to IEEE, Software Engineering is an application of a systematic, disciplined, quantifiable approach to the development, operation, and maintenance of software.

I have summarized these Principles and Practices and I’ll present more details about each of them in additional posts.


Rigor and Formality
creative activity, but it must be practiced systematically, in a predictable manner
Separation of Concerns
“divide et impera” in order to dominate the complexity
divide a complex system into simpler pieces called modules; cohesion and coupling have a decisive role
focus on what should be done, not on how – Identify the important aspects of a problem and ignore its details
Anticipation of change
the support for the software evolution requires anticipating potential future changes
while solving a problem, try to discover if it is an instance of a more general problem whose solution can be reused in other cases
deliver the first prototype and then incrementally add effort to turn a prototype into a product


Clean Code[2]
best practices for code readability and maintainability
usually, used in the test-driven development (TDD)
helps to put in practice the Clean Code principles
SOLID Principles[4,5]
SRP (Single Responsibility Principle): a class should have only a single responsibility (i.e. only one potential change in the software’s specification should be able to affect the specification of the class)
OCP (Open/Closed Principle): “software entities … should be open for extension, but closed for modification.”
LSP (Liskov Substitution Principle): “objects in a program should be replaceable with instances of their subtypes without altering the correctness of that program.”
ISP (Interface Segregation Principle): “many client-specific interfaces are better than one general-purpose interface.”
DIP (Dependency Inversion Principle): one should “depend upon abstractions, [not] concretions.”
Design Patterns[6]
proved solutions/approaches to common problems
specific to different languages/technologies
helps (in some regard :)) to have a safety-net against further changes into the code (very likely to have)


  1. [(Fundamentals of Software Engineering )] [Author: Carlo Ghezzi] [Dec-2002]
  2. Clean Code: A Handbook of Agile Software Craftsmanship
  3. Refactoring: Improving the Design of Existing Code
  4. SOLID (object-oriented design)
  6. Design Patterns: Elements of Reusable Object-Oriented Software
  7. Test Driven Development: By Example

10 thoughts on “Software Engineering Principles and Practices (Work in progress)

  1. Thanks for making the honest try to give an explanation for this. I believe very strong about it and want to be informed more. If it’s OK, as you reach extra intensive wisdom, would you mind adding extra posts similar to this one with additional information? It will be extraordinarily helpful and helpful for me and my colleagues.

  2. Hey, I think your website might be having browser compatibility issues. When I look at your blog site in Firefox, it looks fine but when opening in Internet Explorer, it has some overlapping. I just wanted to give you a quick heads up! Other then that, superb blog!

This site uses Akismet to reduce spam. Learn how your comment data is processed.

%d bloggers like this: