devconcrete

Software Development Principles and Best Practices

View the Project on GitHub dmishh/devconcrete

DevConcrete – Software Development Baseline

Software Development Hard Skills Checklist

In progress…

Software Development Principles and Best Practices

Total number of principles and best practices

Agile manifesto

Url: https://agilemanifesto.org/

  1. Individuals and interactions over processes and tools
  2. Working software over comprehensive documentation
  3. Customer collaboration over contract negotiation
  4. Responding to change over following a plan

12 principles behind Agile manifesto

Url: https://agilemanifesto.org/principles.html

The Twelve-Factor App

Url: https://12factor.net/

  1. Codebase. One codebase tracked in revision control, many deploys
  2. Dependencies. Explicitly declare and isolate dependencies
  3. Config. Store config in the environment
  4. Backing services. Treat backing services as attached resources
  5. Build, release, run. Strictly separate build and run stages
  6. Processes. Execute the app as one or more stateless processes
  7. Port binding. Export services via port binding
  8. Concurrency. Scale out via the process model
  9. Disposability. Maximize robustness with fast startup and graceful shutdown
  10. Dev/prod parity. Keep development, staging, and production as similar as possible
  11. Logs. Treat logs as event streams
  12. Admin processes. Run admin/management tasks as one-off processes

SOLID

  1. The Single-responsibility principle. There should never be more than one reason for a class to change or every class should have only one responsibility
  2. The Open–closed principle. Software entities should be open for extension, but closed for modification
  3. The Liskov substitution principle. Functions that use pointers or references to base classes must be able to use objects of derived classes without knowing it
  4. The Interface segregation principle. Many client-specific interfaces are better than one general-purpose interface
  5. The Dependency inversion principle. Depend upon abstractions, not concretions

KISS

Keep it simple, stupid

DRY

Don’t repeat yourself

YAGNI

You aren’t gonna need it

Eric Raymond’s 17 Unix Rules

Url: Eric Raymond’s 17 Unix Rules on Wikipedia

  1. Build modular programs
  2. Write readable programs
  3. Use composition
  4. Separate mechanisms from policy
  5. Write simple programs
  6. Write small programs
  7. Write transparent programs
  8. Write robust programs
  9. Make data complicated when required, not the program
  10. Build on potential users’ expected knowledge
  11. Avoid unnecessary output
  12. Write programs which fail in a way that is easy to diagnose
  13. Value developer time over machine time
  14. Write abstract programs that generate code instead of writing code by hand
  15. Prototype software before polishing it
  16. Write flexible and open programs
  17. Make the program and protocols extensible