Software Complications

I think I finally understand some of the strange things which complicate the creation of software.

I was involved in testing a small piece of internal software written by one person then handed over to a small group to finish. It mostly worked when he handed it over but was missing some stabilization and fit and finish. Being handed over it fell into a strange mix of complications.

Number of coders When there is one coder, there is one opinion and one style. The program should theoretically be consistent. Adding other coders throws a wrench in the works. Each coder has a different style and a different background. Not to mention they aren't familiar with the other coder's code.

Language complexity The complexity of the language can make things more difficult by hiding useful elements of the language in places some programmers wouldn't think to find or wouldn't know it even existed causing programmers to wrap their own solutions to things which already exist.

Language stability The stability of the language helps quite a bit. If a language is a type-safe language with garbage collection it is more difficult to have more disastrous consequences. Where in a language like C++, if you are not careful the program can leak and corrupt memory.

Project Complexity It is impossible to write a program which does not have errors. There will always be bugs in any program. Even a simple program will have some kind of way it can fail. The more code a program has and the more pieces it accumulates the more bugs it is likely to have. So the number of possible bugs is somewhat proportional to the complexity of the program.

Coder's Programing skill No two programmers have the same skill set or experience. Some have years of college and work experience, while others are new but well taught. Others are self taught, gleaning on the histories of others. As such the ways code is written will vary deeply depending on who codes.

Coder's Language familiarity The familiarity a coder has with a language certainly helps with how well they can code. A lot of languages have a very similar structure so someone familiar with a similar language can generally be somewhat efficient in another. But there are things such as libraries and learning the gotchas of a language which differ. For instance Someone who was educated in C++ can program in C# but they are likely to make things more difficult than necessary. And Someone who was trained in C# is likely to need to heavily use references to get much dome.

All of these things and others can make things difficult. A Programmer who is handed a project but is not familiar with how a program works is likely to unknowingly break parts which work perfectly well, while trying to fix some other part.

It was amazing to see how all of these factors can play into how a program eventually ends up. And the quality of it.