Introduction
Software engineering can be a lucrative, fulfilling career. The world runs on a variety of software applications, whether desktop, mobile or web. There are a lot of university degrees, courses and boot camps that teach the concepts of computer science, software engineering and different programming languages.
However, what is lacking and is needed is a guide to create software applications regardless of technology stacks and if the software is a mobile, desktop or web application. I attempt to provide such a guide below.
Basic Software Engineering Process
The process of building software can be divided into 6 steps: requirements gathering, designing the system, implementation of the system, testing, deployment and maintenance.
Requirements Gathering
The first step involves gathering the end-user requirements of the software to be designed. This step is necessary as without it, we can't design software that meets the end user's hopes and solves their problems.
This step involves communicating with the end user in an attempt to understand what problem they would like to solve. As end users may not be technical, steps should be taken to understand their points of view.
Once this is done, we can build a list of the end user requirements for the software to be designed. From this, we can get technical requirements.
Designing the system
The second step is designing the system so that it matches the user and technical requirements. This will involve making a tradeoff analysis of the benefits and drawbacks of various technologies and choosing the appropriate ones.
At the end of this step, we should know what programming languages, databases, operating systems and hardware we will be using and the architecture of the software. We should also have a list of modules that should comprimise the software.
We can then create a test environment to build the software and a production environment to deploy it once it is ready for the end users.
Implementation
Once the choice of technologies is made, the next step will involve the writing of the code in the programming languages and creation of the databases along with the creation of the user interface.
Testing
Once the code has been written it needs to be tested to ensure that it meets the technical and end user requirements. This can involve both user and integration testing. User testing ensures that all the modules work whilst integration testing is needed to ensure that the entire system works.
If all the necessary tests don't work, the programmer(s) will need to debug their code to ensure that it does. The testing can be done manually or using frameworks such as JUnit. It may also involve code reviews.
Deployment
After testing has been concluded, the software is deployed to the production environment. The end users are invited to use the system. If all goes well, the system is "live". If not, the programmers need to fix the system.
Maintenance
Over time, the user requirements may change, bugs may be discovered or new features may need to be added. The previous 5 steps will need to be done to make the changes. The changes need to be done in a manner so that the existing software's functionality isn't broken.
Additional Considerations
These are the considerations that need to be taken.
1) All steps should be documented for references in the future by different programmers.
2)The end users should be involved in all but the design and implementation stages.
3)User interfaces should be easy to use.
4) The code should be optimized for speed and space requirements and should be easy to change. They should also be written with scalability in mind.
5) Security should be a major consideration from start to finish.
Conclusion
I have given the list of steps to be taken to design a software application. These steps will work regardless of programming languages, databases, operating systems and whether the system is a mobile, desktop or web application. Please leave your opinions below.
Top comments (0)