Software Engineering

Software Engineering Principles and Practices (Work in progress)

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.

Principles[1]

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
Modularity
divide a complex system into simpler pieces called modules; cohesion and coupling have a decisive role
Abstraction
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
Generality
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
Incrementality
deliver the first prototype and then incrementally add effort to turn a prototype into a product

Practices

Clean Code[2]
best practices for code readability and maintainability
Refactoring[3]
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
TDD[7]
helps (in some regard :)) to have a safety-net against further changes into the code (very likely to have)

References:

  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)
  5. http://butunclebob.com/ArticleS.UncleBob.PrinciplesOfOod
  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. Helaine Cisco

    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.

    Reply
  2. Issac Louer

    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!

    Reply
  3. Vance Therurer

    Thank you for another magnificent post. Where else may anyone get that kind of info in such a perfect way of writing? I’ve a presentation next week, and I’m on the search for such information.

    Reply
  4. Aborcja Słowacja

    An interesting discussion is worth comment. I think that you should write more on this topic, it might not be a taboo subject but generally people are not enough to speak on such topics. To the next. Cheers

    Reply

Leave a Reply to Bess Seisler Cancel reply

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