Software development is the process of conceiving, specifying, designing, programming, documenting, testing, and bug fixing involved in creating and maintaining applications, frameworks, or other software components, it includes all that is involved between the conception of the desired software through to the final manifestation of the software, sometimes in a planned and structured process. Therefore, software development may include research, new development, prototyping, modification, reuse, re-engineering, maintenance, or any other activities that result in software products
Software can be developed for a variety of purposes, the three most common being to meet specific needs of a specific client/business (the case with custom software), to meet a perceived need of some set of potential users (the case with commercial and open source software), or for personal use (e.g. a scientist may write software to automate a mundane task).
Embedded software development, that is, the development of embedded software, such as used for controlling consumer products, requires the development process to be integrated with the development of the controlled physical product. System software underlies applications and the programming process itself, and is often developed separately.
The need for better quality control of the software development process has given rise to the discipline of software engineering, which aims to apply the systematic approach exemplified in the engineering paradigm to the process of software development.
There are many approaches to software project management, known as software development life cycle models, methodologies, processes, or models. The waterfall model is a traditional version, contrasted with the more recent innovation of agile software development.
A software development process (also known as a software development methodology, model, or life cycle) is a framework that is used to structure, plan, and control the process of developing information systems.
A wide variety of such frameworks has evolved over the years, each with its own recognized strengths and weaknesses. There are several different approaches to software development: some take a more structured, engineering-based approach to develop business solutions, whereas others may take a more incremental approach, where software evolves as it is developed piece-by-piece. One system development methodology is not necessarily suitable for use by all projects. Each of the available methodologies is best suited to specific kinds of projects, based on various technical, organizational, project and team considerations.
Most methodologies share some combination of the following stages of software development:
Analyzing the problem
Gathering requirements for the proposed business solution
Devising a plan or design for the software-based solution
Implementation (coding) of the software
Testing the software
Maintenance and bug fixing
These stages are often referred to collectively as the software development life-cycle, or SDLC. Different approaches to software development may carry out these stages in different orders, or devote more or less time to different stages.
The level of detail of the documentation produced at each stage of software development may also vary. These stages may also be carried out in turn (a waterfall based approach), or they may be repeated over various cycles or iterations (a more "extreme" approach).
The more extreme approach usually involves less time spent on planning and documentation, and more time spent on coding and development of automated tests. More extreme approaches also promote continuous testing throughout the development life-cycle, as well as having a working (or bug-free) product at all times.
More structured or waterfall based approaches attempt to assess the majority of risks and develop a detailed plan for the software before implementation (coding) begins, and avoid significant design changes and re-coding in later stages of the software development life-cycle planning.
There are significant advantages and disadvantages to the various methodologies, and the best approach to solving a problem using software will often depend on the type of problem.
If the problem is well understood and a solution can be effectively planned out ahead of time, the more "waterfall" based approach may work the best. If, on the other hand, the problem is unique (at least to the development team) and the structure of the software solution cannot be easily envisioned, then a more "extreme" incremental approach may work best.
The sources of ideas for software products are plentiful, these ideas can come from market research including the demographics of potential new customers, existing customers, sales prospects who rejected a product proposal or from internal staff members.
Ideas for software products are usually first evaluated by marketing personnel for economic feasibility, for fit with existing channels distribution, for possible effects on existing product lines, required features, and for fit with the company's marketing objectives.
Because software development may involve compromising or going beyond what is required by the client, a software development project may stray into less technical concerns such as human resources, risk management, intellectual property, budgeting, etc.
A full needs-analysis is conducted on the requirements which the software product needs to fulfil or enhance. The needs-analysis needs to take into account the current process and the delays or frustrations this may be causing. A needs-analysis should also be conducted on a completely new product concept to ensure the software developers are completely aware of all the requirements prior to starting the development of the project These processes may also cause the role of business development to overlap with software development.
Planning is an objective of each and every activity, where we want to discover things that belong to the project. An important task in creating a software program is extracting the requirements or requirements analysis.
Customers typically have an abstract idea of what they want as an end result but do not know what software should do. Skilled and experienced software engineers recognize incomplete, ambiguous, or even contradictory requirements at this point. Frequently demonstrating live code may help reduce the risk that the requirements are incorrect.
Although much effort is put in the requirements phase to ensure that requirements are complete and consistent, rarely that is the case; leaving the software design phase as the most influential one when it comes to minimizing the effects of new or changing requirements. Requirements volatility is challenging because they impact future or already going development efforts.
Once the general requirements are gathered from the client, an analysis of the scope of the development should be determined and clearly stated. This is often called a scope document.
Once the requirements are established, the design of the software can be established in a software design document.
This involves a preliminary or high-level design of the main modules with an overall picture (such as a block diagram) of how the parts fit together.
The development language, application type (windows, web or mobile app), hosting and hardware requirements should all be known at this time. Then a detailed or low-level design document is created and may also include a form prototyping such as wireframes, as a proof-of-concept to confirm all the requirements have been taken into account.
Development, testing and documentation
Development is the part of the process where software developers actually write the source code for the project. This may also include the writing of an API (Application Programming Interface), be it external or internal. The software development phase also requires setting up a code-repository, which ensure recoverability of the source-code as well as enables the software developers to track any changes made to the source code. This is especially important in a multi-developer project, where more than one developer works on the same set of source code.
Software testing is an integral and important phase of the software development process. This part of the process ensures that defects are recognized as soon as possible. Prior to end-user testing, automated code testing is carried out to ensure each part of the source does functions correctly. Generally, a beta version of the software is provided to the end-user(s) or software testers, to test the functionality and report any bugs that they may encounter while using the beta version of the software. All tests should be documented and included in the project documentation to ensure each bug reported has been fixed.
Software developers will frequently provide the end-user with a UA (User Acceptance) document to read and approve, which confirms all the requirements have been included and all reported bugs have been fixed.
Documenting the internal design of software for the purpose of future maintenance and enhancement is done throughout development. The software developers process chosen by the developing team will determine how much internal documentation (if any) is necessary, plan-driven models (e.g., Waterfall) generally produce more documentation than Agile models. The documentation should also include various UML diagrams detailing the process flow of each function or workflow.
Deployment and maintenance
Deployment starts directly after the code is appropriately tested, approved for release into a production environment. This may involve installation, customization (such as by setting parameters to the customer's values), additional testing, and possibly an extended period of evaluation. A very important element of software development which is frequently overlooked, is a thorough security or vulnerability assessment to ensure the production environment and source does not contain any exploitable vulnerabilities which can put the end-user at risk. The LIVEX Cyber Security team is specialized in this area to ensure all vulnerabilities are corrected.
Software training and support is important, as software is only effective if it is used correctly. Maintaining and enhancing software to cope with newly discovered faults or requirements can take substantial time and effort, as missed requirements may force redesign of the software
The LIVEX Software development team is highly skilled in all areas of development and can develop the perfect software system for your business needs.