Standard Practices
Lets go over the the standard practices through every phase of a project
Research Phase: #
Broad-Minded Approach: To be a good developer, you need to explore all possible solutions. Use Google, ChatGPT, Stack Overflow, and ask friends or colleagues for help. Don’t limit yourself to familiar solutions; try new methods and technologies. For example, if you’re working with PHP and face a tough problem, look at how similar issues are solved in other programming languages.
Communication and Networking: Always communicate with your team lead and peers. Regularly update them on your progress, what you’ve tried, and what works or doesn’t. This keeps everyone informed and opens up chances for team problem-solving.
Timely Reporting: Set a specific amount of time for research, but try to finish early if you can. If you have two days for research but find a solution in one, use the extra time to refine your work or start the next task. Reporting your progress helps keep the project on track.
Confidence and Feasibility: Assess if the solution you’re researching is likely to work. Tell your team lead if you need to change direction. Being proactive helps manage expectations and guides the project correctly.
Development Phase: #
Strict Scrum Adherence: Follow Scrum ceremonies and processes carefully. This includes sprint planning, daily stand-ups, sprint goals, mid-sprint reviews, and retrospectives. Make sure the team lead has all stories in the backlog and maintains the epics before starting a sprint. Use Jira to track tasks and deadlines and ensure Scrum ceremonies are not forgotten.
Best Coding Practices: Stick to best coding practices. Write clear comments on your code, clean up unused code, and format files before committing them. Consistent coding styles and naming conventions help. Following PSR-12 for PHP projects can significantly improve code readability and maintainability. Adopting a style guide ensures uniformity across the team.
Clear Communication: During daily stand-ups, talk to team members if you need access to files they are working on to avoid conflicts. Use Slack for structured communication at key points like the start and end of sprints, before and after big code changes, and during testing phases. Clear communication helps prevent misunderstandings.
Unit Testing: Do your own unit testing, covering both common and rare cases. Use automated testing tools like Chrome extensions to input many test cases. Run all tests every time you change the code. Share these tests with the tester after submitting your code. Good error handling and logging make debugging easier and improve reliability.
Do Your Own Unit Testing: As a developer, it’s crucial to test your code thoroughly before handing it over to testers. Begin by writing unit tests for all the functions and modules you develop. Unit testing involves testing individual components of your software to ensure they work correctly. This step helps catch bugs early and ensures that your code performs as expected in isolation.
Test not just working cases but edge cases and rare cases: While it’s important to test your code under normal conditions, it’s equally critical to test edge cases and rare scenarios. Edge cases are unusual situations that occur at the extreme ends of operating conditions, such as the minimum and maximum values a variable can take. Rare cases might include unexpected user inputs or unusual usage patterns. For example, if you’re developing a login function, test it with valid credentials (working case), invalid credentials (edge case), and unusual input like SQL injection attempts (rare case). Testing these scenarios ensures your code can handle unexpected situations gracefully.
Install a Chrome extension for running automated tests: To streamline the testing process, use automated testing tools. Chrome extensions like Selenium IDE can record and playback user interactions with the browser, making it easier to create automated tests. Once you have recorded the necessary interactions, you can run these tests automatically whenever you change your code. This practice helps ensure that new changes don’t break existing functionality.
Input as many tests as you can into this extension and run them every single time you change the code: Maximize the effectiveness of your automated testing by creating comprehensive test cases. Input as many scenarios as possible into the Chrome extension, covering both typical and atypical use cases. Make it a habit to run all these tests every time you modify your code. This continuous testing approach helps identify issues early and reduces the risk of introducing new bugs.
All members of the team will install one pre-decided Chrome extension which can record and auto-run tests: Standardize the testing process across the team by agreeing on a single Chrome extension for recording and running automated tests. This consistency ensures that all team members use the same tools and methodologies, making it easier to manage and review tests. Having everyone on the same page enhances collaboration and maintains uniform testing standards.
Once all of the tests are completed successfully during the unit test, export all these tests and give them to the tester after submitting the code for testing: After you’ve run your unit tests and confirmed that all tests pass successfully, export the test cases. Provide these exported tests to the testers along with your code. This documentation helps testers understand the scenarios you have already covered, allowing them to focus on more extensive integration and system testing. It also ensures that your initial testing efforts are transparent and verifiable.
Example: Suppose you are developing a feature for an e-commerce website that involves adding items to a shopping cart. Your unit tests should include:
- Working cases:
- Adding a single item to the cart.
- Adding multiple items to the cart.
- Updating the quantity of an item in the cart.
- Removing an item from the cart.
- Edge cases:
- Adding an item with the maximum allowable quantity.
- Adding an item with zero or negative quantity (should fail).
- Rare cases:
- Adding an item with special characters in the name.
- Simulating network failure during the add-to-cart operation.
You would use a Chrome extension like Selenium IDE to record these actions and save the test cases. Each time you make changes to the shopping cart code, you run all the recorded tests to ensure everything still works correctly. Once you’re confident that your code is stable, export the test cases and hand them over to the tester, along with your code, for further validation.
Code Reviews: Conducting code reviews is a critical practice that ensures code quality and fosters a culture of continuous improvement.
Weekly Code Reviews: Code reviews are mandatory every week for each developer’s tasks. This regular schedule ensures that all code is consistently checked for quality and adherence to best practices.
Peer Reviews: Reviews should be conducted by peers with the same or higher experience level, preferably from outside the current project team. This external perspective can provide unbiased feedback and new insights.
Time-Bound and Non-Blocking: Code reviews should be time-bound to avoid delaying the development process. Setting a specific timeframe for reviews ensures they are completed efficiently and do not become a bottleneck.
Constructive Feedback: Feedback during code reviews should be constructive, specific, actionable, and respectful. The goal is to help improve the code and the developer’s skills, not to criticize. For example, instead of saying “This code is bad,” suggest, “Consider refactoring this function for better readability and performance.”
Learning-Oriented and Collaborative: The review process should be seen as a learning opportunity. Encourage a collaborative approach where both the reviewer and the developer can discuss the code and share knowledge. This can lead to better solutions and a more cohesive team.
Smaller, Manageable Parts: Reviewing smaller, manageable parts of the code can make the process more effective and less overwhelming. Breaking down the code into logical sections allows for more focused and detailed feedback.
Consistent Structure and Guidelines: Maintain consistency in the review process by following a standard structure and guidelines. This uniformity ensures that all reviews are thorough and adhere to the same quality standards.
Example of a Code Review Process:
- Preparation: The developer prepares the code for review by ensuring it adheres to coding standards and is well-documented. The code is then pushed to a shared repository.
- Assignment: A peer reviewer is assigned, preferably someone with similar or higher experience but from outside the current project team.
- Review: The reviewer goes through the code, checking for functionality, readability, adherence to standards (like PSR-12 for PHP), and potential improvements.
- Feedback: The reviewer provides detailed feedback, highlighting what is good and suggesting improvements where necessary. The feedback is specific and constructive.
- Discussion: The developer and reviewer discuss the feedback. This collaborative discussion helps clarify any points and leads to mutual understanding and agreement on the changes.
- Revision: The developer makes the necessary changes based on the feedback and resubmits the code for a final check.
Approval: Once the reviewer is satisfied with the changes, the code is approved and merged into the main codebase.
Deployment Phase: #
During the deployment phase, the focus shifts to ensuring that the software is properly set up in the production environment. As a developer, your role is crucial in making sure the code is ready for deployment and supporting the process as needed.
Code Readiness #
- Ensure Code Completeness: Before deployment, make sure all your code changes are complete and well-tested. This includes addressing all feedback from code reviews.
- Final Unit Testing: Perform a final round of unit testing to ensure that no bugs have been introduced during the last stages of development.
Deployment Preparation #
- Version Control: Ensure your code is properly committed and pushed to the main repository. Follow the version control guidelines strictly to avoid conflicts and ensure a smooth deployment process.
- Documentation: Update the technical documentation to reflect the latest changes. This includes API documentation, deployment scripts, and configuration files.
In-Office Deployment #
- Office Presence: Deployments are always conducted in the office. On the day of deployment, be prepared to stay in the office until the deployment is declared successful. Your expertise may be needed to resolve any issues that arise during the process.
- Deployment Planning: Work closely with your team lead to understand the deployment plan and your role in it. This may involve setting up staging environments, performing final checks, or supporting live deployment.
- Simulation and Dry Runs: Participate in deployment simulations or dry runs. These help identify potential issues before the actual deployment and ensure everyone is familiar with the deployment process.
Production Phase: #
Once the software is deployed to the production environment, it becomes live for the client. As a developer, your role involves ensuring the software runs smoothly and addressing any issues that arise.
Monitoring and Support #
- Active Monitoring: Keep an eye on the production system’s performance. Use monitoring tools to track key metrics and identify potential issues before they impact users.
- Bug Fixes: Address any bugs or issues reported by the client or detected through monitoring. Aim to fix and deploy these issues promptly to minimize disruption.
Code Quality and Performance #
- Optimize Code: Continuously look for ways to optimize your code for better performance and reliability. This includes refactoring code, optimizing queries, and improving resource management.
- Adhere to Standards: Ensure all code changes in the production phase adhere to the coding standards and best practices. This maintains the quality and consistency of the codebase.
Collaboration #
- Team Coordination: Work closely with the QA team to test fixes and updates before deploying them to production. Ensure clear communication with your team lead regarding the status of any issues and fixes.
- Regular Updates: Provide regular updates to your team lead about the production system’s status, any issues encountered, and the steps taken to resolve them.
Update Planning #
- Careful Planning of Updates: Plan the pushing of updates to the production environment carefully to ensure minimal disruption to the client’s activities. Coordinate with your team lead to determine the best times for updates, ideally during periods of low client activity.
- Client Communication: Ensure that the client is informed in advance about any planned updates, especially if downtime is required. Provide an accurate estimate of the downtime and any potential impact on their operations.
- Downtime Management: If downtime is necessary, plan it in such a way that it causes the least inconvenience to the client. Schedule updates outside of the client’s peak hours, such as late evenings, early mornings, or weekends.
- Rollback Plan: Always have a rollback plan in place in case the update causes unforeseen issues. Ensure that you can quickly revert to the previous stable state to minimize any potential disruption to the client’s activities.
Maintenance Phase: #
The maintenance phase focuses on ensuring the software remains stable and continues to meet the client’s needs. As a developer, your role involves addressing minor updates, bug fixes, and ensuring the software runs smoothly, even while you may be assigned to other projects.
Regular Maintenance Tasks #
- Scheduled Maintenance: Participate in scheduled maintenance activities such as updating dependencies, patching vulnerabilities, and cleaning up the codebase.
- Minor Updates: Implement minor updates or enhancements requested by the client. Ensure these changes are thoroughly tested before deployment.
Balancing Maintenance with Other Projects #
- Prioritization: Assess the priority of maintenance tasks in comparison to your current development tasks. High-priority maintenance tasks should be addressed promptly to ensure the stability and reliability of the production system.
- Time Management: Make time to complete maintenance tasks based on their priority and deadlines. Coordinate with your team lead to effectively balance your workload between maintenance and development projects.
- Task Scheduling: Schedule your maintenance tasks around your development work. This may involve setting aside specific times during the week to focus on maintenance activities.
Issue Resolution #
- Timely Bug Fixes: Address bugs and issues reported by the client promptly. Ensure thorough testing of fixes to prevent recurrence.
- Client Feedback: Use feedback from the client to improve the software. Implement changes that enhance user experience and address client needs.
Continuous Improvement #
- Code Refactoring: Regularly refactor the code to improve readability, maintainability, and performance. This ongoing process helps keep the codebase healthy and reduces technical debt.
- Skill Development: Continuously work on improving your skills and knowledge. Stay updated with the latest technologies and best practices to contribute effectively to the project.
Collaboration and Reporting #
- Team Collaboration: Work closely with your team lead and other team members to ensure a smooth maintenance process. Share knowledge and collaborate on resolving complex issues.
Documentation Updates: Keep the documentation updated to reflect any changes made during the maintenance phase. This includes updating API documentation, user guides, and internal technical documentation.
