Seeing the huge number of competing open source projects in basically every programming language raises some questions.
Primarily is it good for us?
Competition certainly drives innovation forward, but having multiple efforts that only slightly differ from each other is probably more of a waste of time and energy.
So why do so many people create libraries and end-user applications that are so similar to other solutions? Why are they not collaborating to create a better tool for both people?
Just one example, on this site you can find 351 Static Site Generators. Many programming languages having 7-8 different implementations.
- Does this happen because it is easier to start a new project than to contribute to an existing one?
- Is it because, despite going on about "the community", in reality we prefer to work alone rather than cooperate?
Top comments (11)
Have you tried workng with someone who is not willing to play nice ? That is why workng alone seems way easier, yet if an individual is not capable of making decisions, then working alone is worst mistake to make.
Actually I try to avoid those :-)
We shouldn't have to work alone. I miss peer reviews when I am the only coder, and automated tools are only a partial replacement for another human eye. But on the other hand it's worse having to work with someone who gets in our way or who behaves unpleasant or unprofessional, and there are so many of those coworkers, team leads, and customers in corporate culture. So I prefer to work on my own most of the time, but it's good, especially for larger and non-trivial projects, to collaborate!
I believe it highly depends on who you work with and what.
One of my lead devs and I sometimes come together to bootstrap some idea or prototype quickly. Such phases are highly efficient and fun. They would not work on productive projects though.
On the other hand, customer projects require lots of dedication. There's a saying like 'too many cooks spoil the food', which is somewhat accurate. If you work alone on a more extensive codebase, however, it's hard for other devs to pick up if you are out of order for some reason. Also, there is usually the economic issue that customers are not willing to pay for two devs when the work can be done by one.
Personally, I prefer working alone given the choice. I do regularly consult with other devs, but really enjoy being in charge of making my own decisions (and mistakes)
The tradeoff is that when you work alone, you work faster especially initially, whereas when you work in a good team, you can go far together.
I personally know that I have already had a few different experiences in my 2 months of web developing, when I ask for help or feedback I am on the receiving end of harsh criticism or condescending attitudes. I haven't been doing this long enough to really get frustrated by it, but I definitely feel safer working alone using google than I do feel safe going out of my way to ask for advice even this early into things.
That's quite bad, but unfortunately there are (many?) people out there who like to take out their own frustration on others. Was this inside the workplace or was it on some public forum?
There is no straightforward answer to this question as it depends on various factors, such as the type of work, the personalities of the people involved, the level of collaboration required, and the goals of the project.
Some people may prefer working alone because it allows them to focus better on their tasks without distractions or interruptions from others. Working alone also provides greater control and flexibility over one's schedule and working style.
However, others may find working with others to be more beneficial. Collaborating with others can provide new perspectives and ideas, divide tasks and responsibilities, and allow for greater efficiency and productivity. It can also lead to better decision-making and problem-solving by leveraging the strengths and skills of each team member.
Ultimately, whether it is easier to work alone or with others depends on individual preferences, the nature of the work, and the specific circumstances of the project.
If the projects are very similar, my guess is that either:
The author of one didn't know about the already existing project.
The existing project didn't do everything exactly as needed. It's arguably better to have one implementation of something that does it really well, than to have an implementation with lots of branching that can do things in slightly different ways.
The author didn't like/couldn't wait for the PR process.
As for alone vs a team, I'd say go alone if you want to go quick; be a team if you want to go far.
There are always a lot of disagreements in the team, different experiences and preferences. When you work alone, you are left to yourself, it's hard, but the result is usually better, the result is individual, without a combined hodgepodge of different technologies and programming languages. There will be a common language, there will be a team, otherwise I will agree with the author — it is better to be alone...
All it takes is one bad apple on a team to bring productivity to a crawl and quality to go down the toilet. I could tell you some real horror stories of arrogant, unprofessional, lazy people who had no work ethic, no skills, nor any pride in their work.
Some coders may be very introverted night-people who keep weird work hours. This may affect working with others depending on how work is allocated and how often deliverables are expected. It can be a lot easier to just work alone at your own pace and time.
Another factor about existing projects: sometimes some project states it does what you want, but the documentation is so bad, and the code so hard to understand that a person just ends up saying: "screw it, I'll write the code myself". Does it save time? Probably not, but programming enthusiasts enjoy writing the code and don't enjoy being frustrated trying to figure out something with bad documentation.
You can probably add ego of the coder as another reason when the coder believes that they can do a better job than all the other solutions out there. Let's face it, many of us coders know we are Gods! :-)
Sometimes folks know that there will be existing solutions to do what they want to do, but write their own solution, solo, anyway, because they enjoy the activity, and they want to learn something. It might start off as just a throwaway experiment that turns out to be useful and ends up getting shared.