You make the same mistake on multiple projects like reggie weed strains and people start to back away from you. You no longer have a good reputation in your company or community. When this happens, it is often too late to save yourself and your company. Follow these 10 warnings to avoid falling into this trap. They are easy mistakes to make, but they can lead to a catastrophic end for all those involved if you don’t fix them quickly!
This blog post highlights ten common mistakes which can cause an ecosystem around the project you are working on (and its future) to fall apart quickly.
1. You don’t communicate important information
This is a pretty big mistake. When you are involved in a project, it’s hard to know what everyone wants to know. But the information should be there for everyone. Ask yourself the following questions:
– What information do users need?
– What data is important for me and my company?
Often this information is not just access to your source code, but also documentation, tutorials, or even that you are working on certain features. Tell people when you make a decision and why it was made. Don’t hide any information!
2. You don’t listen to feedback
Sometimes people will have good advice or even criticize you or your decisions. But if you don’t listen to feedback, it is nearly impossible that you can correct or improve anything. Listen to the feedback and be ready to change course.
3. You don’t have specifications for your code
If you are working in a team, there is always someone else involved in the project. Without a set of clear specifications for the development, it’s impossible for the other developers to produce anything useful. This will also prevent repeatable tests so that problems can be found earlier on in production.
4. You don’t give developers an understandable coding standard
Often there are many people working on a project and they need to collaborate on everything from writing tests, creating documentation, or even implementing new features of your application (or framework). Without a standard code, there is no way for them to know how to write tests, add documentation for example. So always set a system where everyone can follow every step of the development process.
5. You don’t document your APIs
Also when you are working in a team, it’s in your interest to make sure that the other developers know how to use your APIs correctly and that they implement the necessary features correctly in your application. Having good documentation helps with this at all times. This can also help prevent errors and bugs in the future regarding this area.
6. You don’t fix bugs or write tests
You made a mistake in your code and it has been found. You have to do something about it. If you just don’t fix the bug, you will lose trust in your project and that’s not a good thing for anyone. Also when writing new features, add test cases for this feature and ship them with your project. This helps reduce errors and it also gives the user peace of mind that your application is well tested, something which is becoming more important on large projects these days.
7. You don’t know your users
It is important to know who you are building software for and what their problems are. While you may think that you know everything about this, it’s always good to try a new perspective. If you do it enough, other people will notice that you care about them a lot and they will be more willing to help you in the end! Also make sure that your users can contact you directly whenever they have questions or suggestions. It’s also not a bad idea to start some sort of community around your project.
8. You don’t make recurring payments
If you are working in a team, you’ll find that it’s hard to communicate with all the different people who have a stake in your project. Some people won’t want to do anything without getting paid first. So you have to tell them! Also, this will prevent problems such as bad communication or disputes over money. If everyone knows that they will be paid regularly and everyone can see how the budget is used, problems should not arise any more.
9. You don’t use version control software
Having a version control system is of course important when working on a team or company project. Everyone should know where the project stands and what code has been committed so far. If there are problems, you should be able to go back to a previous version of the software if necessary. This can prevent a lot of problems in the end, especially when working with non-technical people who simply don’t understand the consequences of their changes.
10. You don’t make decisions
When working on an open source project, it’s hard to make decisions and get things done sometimes. But making quick decisions can help you progress with your work which is something that most developers need if they want to use your projects as part of their own applications as soon as possible.
These ten reasons why you should never start an open source project are easy to make but can cause a lot of harm when not corrected. If you have any other reason, write a comment and add it to the discussion!
If you’ve ever started an open source project and have made similar mistakes, tell us about it in this blog post. I’m sure a lot of people will learn from your experiences!