Sustained Development Guide
Summary
This guide provides a set of methods and practices that aim to ensure the continuous development and deployment of high quality software.
Key focus areas
- Documentation
- Reusability
- Maintainability
- Testing
- Security
- Speed
- Feedback
- Support
- Training
Key area: Documentation
Proper documentation keeps everyone able to focus on the actual development work instead of having to figure out how something works, how something is done or what they are supposed to do.
Specification
Make sure proper specification is always done before starting any technical work.
Example: Create a route flow, feature plan and at least some form of initial design before starting prototype
Project documentation
Keep project documentation always up-to-date, so everyone can work on the project.
Example: Database structure, route flow, build/run/deploy instructions
Wiki
Maintain proper documentation of work practices, techniques and plugins.
Example: Workflow tutorials, MCU and feature how-tos, training material, new member onboarding..
Key area: Reusability
To avoid doing the same things over and over again, we design and develop reusable software pieces that work together dynamically to fulfill multiple projects’ needs.
Features
Design general purpose implementations of application features and expand the feature based on project requirements.
Example: Booking-feature first made for Isku Booking (meeting rooms), then expanded for Etera Työhuone (workspace, pin lock-integration) and is to be expanded again for Sello (parking lot system integration).
Modules, Components & Utilities
Bundle as much of the UI and functionalities into ready-to-use package. The goal is to create a vast library of handy view modules, UI components and coding utilities so we never have to code anything twice, and that we can create new features very fast (with plug ‘n play view modules).
Example: Part of the booking-feature would be view modules called “Event” (= booking info) and “Calendar” (to make the booking). The view modules would use at least a bunch of form field components and a button component. We could also use general purpose “DateTime calculations” and “Booking” utility libraries for the code of needed to manipulate time variables and handle the actual booking reservations. Remember that phase 1 MCUs can reside inside a project or feature (we just need to documentate somewhere that your package exists).
Key area: Maintainability
When the amount of projects and lines of code is increasing, keeping everything easily maintainable becomes very important. We can improve code maintainability by removing any extra complexity and by always following the correct methods and practices.
Simplicity
Write simplified, straight to the point code without doing unnecessarily complex implementations.
Example: When you start a new utility or feature, start with the least possible amount of functionalities and remember that a phase 1 package can have project-specific code inside.
Consistency
Follow coherent language idioms, patterns, conventions and styles.
Example: Use the correct syntax when coding, always place project files in the correct folders, do all necessary required steps for every project.
Correctness
Make sure implementations match the specifications, are bug free and do not break or put the app to a corrupt state.
Example: Read the instructions and ask your colleagues if you are unsure about something. Do proper testing, bug fixing and use the proper pull request -workflow with all your coding.
Key area: Speed
When working on multiple projects with deadlines simultaneously, it is vital to avoid getting stuck by continuously shipping new versions of project software and quickly reacting to anything blocking or delaying tasks.
High speed comes from focusing on the goals at hand, establishing a good work routine and reaching a high level of technical proficiency. It does not mean badly done, unfinished or untested. It means focusing on the important things, doing them right and trying to improve every time.
Minimalism
Design everything to be simple and improve gradually. Use the iterative process to add new functionalities and improvements.
Example: In login module, you initially just need a username-field, password-field and a login-button to use the module in a testing version. You can add new functionalities, such as the “Remember me”-checkbox, in a new round of updates.
Focus
Focus on the necessary and disregarding the unnecessary. Always focus on the most important tasks that are needed to reach your current goal. Use the iterative process to build improvements after you finish all the minimum requirements needed to reach a project goal.
Example: When working on early versions of a project software, like prototype or a testing version, create a functional “sketch” of the software first by doing the minimum necessary functionalities to meet the project requirements, and then start adding improvements and enhancements on top in later project stages.
Time management
Plan a project schedule, keep track of deadlines and react quickly to prevent possible delays. To be successful, it is important to be able to measure project accuracy, quality and efficiency. This could be done by splitting a project in smaller sub-projects and to individual tasks, estimating the time needed to complete the tasks and tracking the actual time spent doing them.
Example: Properly splitting a project to small steps and putting extra effort on time estimations. Switching more teammates to work on a higher priority task if it looks like the actual time needed for the task is higher than the original estimate.
Key area: Testing
Ensure that the software functions properly and that all task requirements are met.
Testing in tiers
There are multiple tiers of testing provided before the release of any software versions. Initial testing is done by the developer. Later, the code is included in a pull request, which is reviewed and tested. Each project version is also reviewed and tested before deployment to live environment.
Example: Test your code properly before commiting or deploying it. Each round of bug fixes requires it’s own round of task specification, assignment and testing which takes more time.
Multi-device testing
Testing should be done on multiple devices as much as possible (ie. computer and a smartphone or tablet). This provides a lot of real world feedback about the performance and usability of the app.
Example: Developer tests patch with desktop & Android-smartphone, Sr.Developer tests the pull request with laptop, Android-tablet & iOS-smartphone
Key area: Security
Security reviewing
Security reviewing must be included in testing tiers. Separate security testing checklists need to be implemented (which include both code reviewing & manual testing tasks).
Example: Developer goes through a security checklist when testing their newest feature update. Senior developer goes through another security checklist when testing a project build or reviewing a core pull request.
Security auditing
Third party consultants are used to periodically audit our software and improve it’s security.
Account & service security
Sensitive data, such as passwords and credentials are to be stored in a password-protected secure place..
Hardware security
All devices must have up-to-date security tools and proper security settings along with always having backups of any important data.
Key area: Feedback
Setting proper channels to receive feedback, analyzing it ja improving based on it is a key factor in making a successful product or service.
Public feedback channels
To be able to receive feedback, set up the standard channels for each project and client.
Example: Set up the feedback-feature for every app project (f.ex. inside My account / Settings-tab if not separately in bottom nav or elsewhere), direct the feedback to client’s email & Trello board. Make sure the Trello-board is integrated to a Slack-channel and also that the client & beta testers know where and how to send any feedback and questions.
Review & retro meetings
Internal review meetings are kept before deploying and shipping a new software version. The point of a review meeting is to determine the version’s readiness for production use, and to discuss the successes and challenges of the project step.
Retro meeting is held to evaluate the project after release to production, and to discuss things to improve in the team’s work process.
Example: Hold a review meeting before you deploy a new version to production. The meetings goal is to ensure that the new version matches the project and quality requirements.
Code reviewing
Senior developers evaluate the quality of new source code of pull requests, and provide teammates important feedback and improvement suggestions. This way everyone keeps improving their skills.
Example: A group of developers are named as Senior Developers, who review and accept/reject all pull requests.
Key area: Support
User guide
Maintaining a proper product / project usage documentation for the end user is vital in minimizing unnecessary training sessions and end user support requests.
Example: Update the project / product user guide on every new version release.
Support developer role
Support developer handles bug fixes, backlog coding and can be assigned to a delayed project as temporary help. Their mission is to handle unexpected critical development tasks (such as bugs) and to provide coding support where needed.
Example: One or more developers assigned as a support developers.
Key area: Training
Training sessions
Keep short regular training sessions where you present something you have done previously. It’s a great way to share the knowledge you have gained on a subject to other teammates, and also to get important feedback about your work.
Example: Everyone holds training sessions twice a month
Code reviews
Code reviews and feedback are forms of mentoring-based skill training.
Example: All pull requests are reviewed by Senior Developers.
Reading knowledge base
Maintain a list of great articles and tutorials for any common subjects you might face (in the wiki for example).