Third-Party Library Management

1. Maintain a registry of third-party libraries within the project's documentation space (Confluence, Wiki) and ensure regular updates by the technical lead or architect.
2. Ensure compliance with the licensing agreements of any third-party libraries utilized.
3. Instead of direct usage, incorporate third-party libraries via a facade design pattern to minimize tight coupling, allowing for easier replacements in the future.
4. Conduct integration tests to cover third-party library code, ensuring that updates to the library do not disrupt application functionality.
5. Opt for libraries that are actively maintained to ensure reliability.

Logging & Monitoring Practices

6. Choose the most suitable logging level (Trace, Debug, Info, Warning, Error, etc.) for each logged message.
7. Configure logging levels to be adjustable via configuration files without necessitating a code redeployment.
8. Implement structured logging techniques to facilitate log analysis through query writing.
9. Ensure that the transmission of logs to monitoring tools does not hinder application performance; utilize non-blocking logging and consider batch processing in separate threads.
10. Utilize monitoring tools such as Application Insights or Stackdriver, configured to send alerts when certain application thresholds are exceeded.

In this insightful video, learn key strategies for software development managers and tech startups to improve their operations and team dynamics.

Code Review Best Practices

11. Prioritize code reviews above development tasks to prevent lengthy pull requests.
12. Automate the code review process using tools like GitHub, Crucible, or Review Board.
13. Limit code review submissions to 300-400 lines, encouraging the division of extensive functionalities into smaller, reviewable segments.
14. Allow reviewers to log the time dedicated to code reviews.
15. Ensure that reviewers clearly understand the acceptance criteria for the code they are evaluating.
16. Utilize a code review checklist available within the project space for all developers.
17. Require at least one or two team members to review each commit before merging into the main branch.

Technical Debt Management

18. Promptly create detailed technical debt tickets within the issue tracking system upon identifying tech debt.
19. Organize technical debt tickets through epics, labels, or a consistent naming convention.
20. Mitigate the accumulation of technical debt by incorporating a few related tickets into each sprint or allocating an entire sprint to address tech debt.
21. Prioritize and estimate technical debt tickets during backlog refinement sessions.
22. Ensure all stakeholders can easily locate technical debt tickets.

Estimation & Process Planning

23. Involve the entire development team in estimations rather than limiting participation to just the technical lead or architect.
24. Clearly define and publish the Definition of Done (DoD) for user stories in the project space, ensuring team consensus before estimations.
25. Utilize 3-Point estimation or the PERT Formula instead of relying solely on single-value estimates.
26. Include efforts for unit testing, code reviews, and testing activities in estimates.
27. Employ techniques such as analogy-based estimation, story points, planning poker, and task decomposition during estimation.
28. Regularly review and refine existing estimates during backlog grooming or sprint planning meetings.
29. Engage all team members in the sprint planning process.
30. Ensure all developers participate in the design phase, not just senior personnel.
31. Delegate work through well-defined tasks by technical leaders.
32. Establish written acceptance criteria for each task.

Source Code Management

33. Store the project source code and all related scripts (database, build, deployment) in a version control system.
34. Each commit should reference a work item ID from the issue tracking system along with a descriptive message.
35. Developers should push changes to feature branches multiple times daily.
36. Ensure that each commit addresses functionality pertaining solely to a specific work item.
37. Merge approved pull requests into the main branch promptly to avoid conflicts.
38. Exclude compiled binaries and third-party packages from source control by configuring the gitignore file.
39. Keep environment-specific configurations, such as connection strings, separate from the source code, utilizing configuration files or environment variables.
40. Define and document branching and merging strategies that suit the project's requirements within the project space.

Database Change Management

41. Store database schemas and reference data in source control.
42. Choose between state-based and migration-based approaches based on project needs.
43. Always modify the database through scripts in source control; if changes are made directly, replicate them in source control.
44. Each developer should maintain a local database that can be easily created using repository scripts.

Continuous Integration and Delivery

45. Document the continuous integration workflow and share it with the team.
46. Include a static code analysis tool in the continuous integration pipeline, ensuring builds fail if code quality metrics fall below standards.
47. Ensure the continuous integration pipeline runs all unit tests, causing builds to fail if any tests do not pass.
48. Encourage developers to run unit tests locally before committing code to the repository.
49. Configure build notifications so the build server alerts relevant parties about build status.
50. Implement semantic versioning for build artifacts.
51. Associate each build with its corresponding repository commit.
52. Define and configure rollback procedures for failed deployments.

Code Quality Assurance

53. Regularly collect and analyze code quality metrics to swiftly identify and address code issues.
54. Ensure all team members utilize the same static code analysis tool with uniform configurations as that of the build server.

Consider subscribing to my Telegram channel, Software Development Daily, for more insights and articles.

In this video, Nicky Thompson discusses effective software engineering practices to enhance management, offering valuable insights for technical leaders.