Some software development common sense ideas

 I haven't really written here in a long time so it's time to write some new things. These are just some random common sense things that seemed to short to write about individually but seem really interesting and useful to me or other people

1. There is nothing fixed in software development, all things vary by circumstances and time

Remember the documentation that didn't seem that important when you started the project, well after a couple of years one the application has grown and become really complicated, no one actually knows everything about the application anymore. So now you really need that documentation. What happens if you suddenly need much more people to develop the application because of some explosive growth? Without documentation, new developers will just look at the application like they look at a painting. This actually happened to me.

Maybe in the beginning of a project, a technology really helped you a lot but as the project grew, it started making things worse that actually helping.

2. All technologies and most things have disadvantages for sure and for the best things there are circumstances where they might make things much worse. Or when they are taken to the extreme, they make things worse for sure. 

Take for example the agile manifesto that says "Responding to change over following a plan". This can be a good thing in a lot of cases. But if you always change things and never stick to the plan, you will never get things done in some cases. 

Maybe some feature just keeps endlessly getting redesigned after it has started being developed. In this case the real problem is the fact that hard data is actually needed to figure out how to design the feature properly and not just to change the plan. 

But to get hard data, you need to release in some way the feature as a test or prototype and get real life data for it.

3. We all have different ways of thinking, as individuals and as groups which where molded by our own unique experiences that we had. And we imprint the way we think into everything we do in software development, most of the time without us even realizing, either as a group or as individual persons.

People with similar mindsets will have less trouble picking up the work or using the work that the other person/group made. This explains endless arguments between various groups of people saying that their technology is the best, like Angular vs React people. In truth, each of those is best for the people in their respective groups with their specific mindsets.

Another example, would be functional programming which for someone with a mathematical inclinations, will have a natural tendency for that style of programming because functions are also important in math.

4. Naming things gives you a good idea of how a good and clear idea you have in your mind about the code, what is supposed to do and how it's supposed to do that. 

If you have trouble naming something, then you don't have a clear enough picture in your head about what you are supposed to do and maybe you even came up with some bad ideas like assigning too many unrelated responsibilities to one class.

5. We might make something that works really well, an architecture that is beautiful but that doesn't mean it actually solves the problem that needs solving. 

Maybe the idea/implementation is really good for a completely different kind of problem but we become emotionally invested/attached and really like how it looks and works, that we try to force it to solve something that it can't solve that well.

6. Actually estimating the pros and cons of something which their real impact, is really hard, almost impossible sometimes.

 And a lot of things go bad because we failed to properly analyze something and determine its actual disadvantages or the impact that they have. And a lot of times, we know what disadvantages something has but we can't asses and estimate the real impact that they have.