Now that we know what software is we need to figure out how to build it, specifically how to build great software. But what makes software great? There are some characteristics I have noted which one can use to differentiate between standard software and great software. Those characteristics include but are not limited to: reliability, efficiency, maintainability and ease of use. Before the software being built can fit those requirements it needs to go through certain steps or checks before and during its development to ensure it meets those standards once the development is complete.
A step which should be happening before the development of any software which aims to be seen as good or even great is careful and detailed planning. Many developers fail in this step because they end up on the polar extremes of this, either planning too little and being surprised when unforeseen circumstances arise during or post development, or they spend too much time planning and due to that there is a lot of time, money and effort wasted on an overly complex plan which may not be implemented as planned out. The aim of planning should be: making sure all parties understand what the problem that the software is going to solve, the features and functionality that will be used to solve that problem and the general design and idea of the software. Once those top level questions have been answered then the more detailed questions can be asked such as: “how will this problem be solved”, “what technologies should we use for our software” and so on.
The next step speaks to using efficient coding practices. Since the plan has been completed and tasks have been outlined now development can start and to build great software as the finished product there should great inputs going in to the software during development. Those inputs include the code being written. Leaving helpful comments, using meaningful variable and function names and sectioning your code into manageable groupings are all efficient coding practices. When these are well implemented the next developer adding on to the code will know exactly what has been done how it is being done and what still needs to be done to complete that particular function.
Another commonly faced problem across many different projects is lack of testing or rather the belief that because there are no errors the code will work as the developer intended. This is a problem that all developers have encountered at some point in their coding journey. The code compiles with no noticeable errors but for some reason the function being implemented isn’t working as it should. This problem wouldn’t be as big of a problem if continuous testing was taking place during the projects development. There will be more on what can be done to test software well in the later stages of this article.
Lastly comes end user feedback. An end user is anyone who actively uses a product so in our software scenario the end users are the people who actually use the software after it had been developed. Receiving this feedback is vitally important to the improvement of future software you will develop as from that feedback you can determine whether or not the software being developed solved the problem and further on that whether the problem was solved well. In some cases software is developed with the mentality of just getting the objective done however, there is a user who will end up using that software so it should be developed with the user in mind in a addition to resolving the stated problem. Getting that end user feedback helps the developers understand what can be worked on during upgrades or maintenance of the software because after all a feature is only as good as it’s user.
Software which has successfully completed these steps during its development life cycle will more often than not display those 4 differentiating characteristics of great software. Ease of use directly refers to the simplicity of the system for its end user. When development is taking place the developers may unknowingly find themselves coding the software according to their skill level and understanding of technology. But there is a pretty big difference in technology literacy of developers and end users in most cases. With that discrepancy in the level of skill if proper care is not taken an unusable solution for the end user may be developed which is definitely not an example of great software. This is why end user feedback is s important, developers need to know what works for the users and what doesn’t the best way to know that is to hear it straight from the horse’s mouth. Such an example could also easily be picked up during the planning phase of the project. Designs and the interface of the software could be discussed during planning and thus this potential problem would be mitigated before the development properly begins.
The maintainability of the software speaks to upkeep of the software after production. With efficient coding practices even if the project is handed over to separate party for maintenance after production that party will be able to understand what had been done to get the software working. With that understanding the party will then be able to apply the changes and updates to the software as requested/ required. This is not to say that software cannot be maintained if no comments were left behind however when buying new DIY furniture would you prefer it came with or without an instruction manual? The points mentioned within the coding practices section serve as a pseudo manual to make the maintenance process significantly easier for whoever performs that maintenance.
Efficiency is a noun sprinkled throughout this entire article, but what does it mean and more importantly what does it mean for software? To be efficient is to achieve maximum productivity with minimum wasted effort or expense. Thus efficiency can be seen as a state at which maximum productivity is achieved with minimum wasted effort or expense. In software that wasted expense or time could be anything from time spent on developing useless features due to poor planning or wasted computing time due to convoluted code. When detailed planning is done well there will be very little spillage of useful effort into wasted effort. Each activity will be seen as a meaningful one with purpose. Making software with the maximum amount of productivity may not always be within ones’ control due to a lack of coding skill maybe or lack of knowledge on the technologies being used but what is within our control is our manual inputs we put into the software. So to improve the overall efficiency of the software a developers aim should be to reduce wasted energy to a minimum through good and effective planning.
Finally we have reliability, the reliability of the software speaks to how often the software does what it is intended to do. Does the software behave as intended in every use case, or are there some instances where unexpected behavior can occur? Reliability may not seem like the most important factor upon first glance because a developers mentality may be to get a particular feature working at least half the time. But if you think f software as in instrument to receive revenue why would you ever only want to receive half of what you could possibly get? Good software will always deliver expected results no matter the circumstance that is what makes it reliable and what builds trust between the developers and end user. In the case of an e-commerce store a customer will may be willfully shopping on a particular site for months but the moment their shopping is interrupted due to something out of their control they will start thinking of alternatives to go to.
So how can we keep software as reliable as possible? As mentioned above for software to be reliable it should be able to perform as intended in all use case scenarios. How will a developer know whether or not the software is performing as expected under different conditions through testing. Testing is being brought up yet again because it is truly essential for good software to become great software. Testing helps mitigate future costs and time spent on fixing software by informing developers of what needs to be fixed now. With testing being so important how should it be done right? Writing unit tests and automated tests as you code will help catch bugs and errors early on before they become massive problems. Making use of shared repo will serve as another code verification step because it will need to be approved by another developer without any conflicts to the main branch before your new code can be successfully merged. And lastly prior to public release the entire software solution should be extensively tested from user interfaces right up to back end functionality this testing can be both automated or manual.
Building software is not an easy task and building great software makes the job just hat much more difficult. However it is not impossible. There are many examples of thriving software solutions in this technological world we find ourselves in. So what was the secret behind their success? They didn’t see the software as this one and done project but rather a continuous process of refinement and improvement. Don’t give up because of a failed or incomplete project rather learn as much as you can from that project to get your next software solution in line with will make it great.
