Software Development Principles

Writing software applications can be very challenging. Following certain software principles can help a ton. Your code can be maintainable and agile if you follow these guidelines.

Software engineers should not be devoted entirely to specific technology. Saying things like, “I only develop in Python”, or “I only want to work with MongoDB databases” is a ref flag. Using certain technology implementations is far less important than following the software engineering principles that should guide them.

Many of these principles are similar to each other, overlap, and the lines between them are blurry.

SubPages

• KISS and YAGNI: Prefer to keep your code as simple as possible.
• Don't Repeat Yourself: Minimize the code duplication.
• Defensive Programming: Carefully consider the trade-offs of defensive programming patterns.
• Single Responsibility Principle: Software components and classes should not be responsible for many concerns.
• Open Closed Principle: Design software classes and components to be easily extended but rarely modified.
• Substitution: Your code should be loosely coupled using abstractions, interfaces, and similar substitution principles.
• Interface Segregation Principle: Function arguments should be minimal interfaces.
• Software Testing: Your software should have ample automated tests across the board.
• Configuration Levels: You should have ample controls over your code from configuration using expressions, templates, and scripts.
• Judging Quality: You should routinely use automated tools to assess your code quality.
• Class Stereotypes: Design your classes to follow effective patterns or stereotypes.
• You Build You Own: Software developers should also be on the hook to support their applications.
• Avoid Globals: Global variables create problems, you should avoid using them.
• Premature Optimization: Avoid optimizing code before proving it is necessary.
• Don't Reinvent the Wheel: Avoid duplication of efforts by leveraging open source.