Software Development Management

Abstract

The software development and management (SDM) practice helps organizations to ensure that their software products are developed methodically and delivered in accordance with the stakeholders’ requirements. The main purpose of the SDM is to map out the management tasks and sequences them rationally. Software must be developed in a systematic manner to ensure that it is developed on time, within budget and with all functional and non-functional capabilities. SDM practice plays a significant role in ensuring that the software is developed in a systematic manner, traditionally using the models such as waterfall model, agile model, and V-model. There are many modern software development models such as DevSecOps that extends the capability of existing models and makes it more cloud friendly. Web-based development and delivery of software applications as well as Low-Code/No-Code (LCNC) are becoming increasingly popular and valuable due to availability of tools and technology for SDM. Selecting the right model for developing software ensures that all the disciplines of that model are implemented and monitored during the SDM process. Hence, SDM practices strategically manage how software is being developed, tested, and deployed and creates the business value for the stakeholders.

1. Introduction

The term ‘software’ has been used for many kinds of computer programs such as a single program or suite of programs ranging from operating systems, middleware, environment, database, desktop, mobile, embedded or web applications. All software products have many unique perspectives such as functionality, development environment, development environment, platforms, users, and way it is being developed and used and hence any single software development and management framework cannot be effectively used for all kinds of software products. Software development and management is a process of developing and managing the required software by adopting various well defined software development life cycle stages. The SDM practice must emphasis on making software reliable, high-quality, and easy to use for users [1]. There are many software-development models that can be used to manage the software development process for achieving these goals however methodology should be selected carefully. Unique challenge presented is that selected SDM must support modern computing environment such as web and cloud where various sub operating environment are dynamic and not fully controlled by any one organization. Deciding which model to use for developing a certain type of software is a complex task. The software developers and managers need to work closely to acquire some knowledge about the software project and then decide which model would work best for the team. The success and failure of the project depends on the selection of the software model [1, 2]. Hence, selecting a proper software model and managing all associated processes and artifacts through various phases of development, are the keys for the effective software development and management. These models articulate the various stages of the process and the order in which the process must be carried out to achieve the required objectives. This paper discusses the various technical and management activities, workflows of the models, and how the models can be improved for future use. Modern and innovative approaches such as continuous integration and Continuous development, and extreme programming are discussed in detail.

2. Purpose

The main purpose of the Software Development and Management Practice is to provide an effective and efficient method for managing software development cycle. SDM practice should be able to manage and address all functional, technical, warranty, operational, and environmental requirements. In addition, the SDM practice must be able to deliver software products efficiently on time and within budget. These goals can only be achieved by applying a systematic approach to manage the software development lifecycle. Software development and management provide an effective framework to develop and manage software applications. The software development and management process will help in effectively planning and managing the process before starting the actual development process [3]. Such methodical approach is efficient and effective in reducing unnecessary costs during the development process which enables the team to estimate the cost of the project. Since such approach allows a systematic process of testing the software before the software is rolled out, the developers can design and build high-quality software products. Hence, the purpose of software development and management is to enhance the software product by evaluating the effectiveness of the software. In modern application development and management practices we must consider effectiveness and efficiency of the approach when the use of such applications software is cloud or web based as well as traditional uses cases such as internally hosted applications.

3. Scope

Software development and management practice covers many different aspects such as design, architecture, development, testing, and finally deployment. The scope of software development and management includes the following architecting the software solution, create a solution design blueprint, software development, testing the solution from various perspective such as unit testing, integration testing, regression testing, software security testing, and user acceptance testing. Stabilization also calls for managing the software product with code repositories, packaging, version control, and patching are also part of the SDM practices. Unique considerations are that such software are deployed and managed thru the cloud and web where many distributed components are not under the control of the organizations.

Scope: After the initiation of the project between the client and the organization, the project manager of the organization assigns the project team. Along with the clients, the organization defines the project scope by using requirement gathering and analysis.

Development: In this stage, the developers set up the development environment framework and develops the code based on requirements decided during the requirement gathering and analysis phase of scoping activity. Developer in this stage also ensures that the software is fit for the purpose.

Stabilization: In this stage, developers focus more on the quality of the software and obtains independent feedback from the testing team. Testing teams carry out various functional and non-functional tests to determine the quality of the software and ensures that the software is fit for the use.

Delivery: The final version of the software is delivered to the customer after the software is tested and the bugs are fixed. Knowledge transfer occurred during this phase with initial support, training, and documentation related with the software solution.

Maintenance and Support: After the software is accepted and released, the ongoing support for troubleshooting, escalated incident support, bug/fix, work arounds, and patching are provided by the SDM team until the end of life for the software solution.

4. Workflow for software development management

The Software development and management process follows the software development life cycle (SDLC) to develop the software within the organization. The SDLC has a detailed plan of how to develop, maintain and upgrade the overall development process. Workflow depicted in the Figure 1 seems sequential, however, it is hardly that simple. Most management approaches include all of the steps but in many different spiral, iterative and analogous combination since such chronological workflow is not effective and efficient in faces changing environments. However tasks carried out in each phases are still relevant and effective.

Figure 1.

Workflow of software development and management.

4.1 Planning and requirement analysis

In this stage, the project managers obtain the requirements related inputs from the clients, sponsors, and different stakeholders of the organization. The data gathered from various stakeholders are used analyze the feasibility of the product in affordable, functional, and specialized areas and to develop the design and the approach that would work best for the scope and within the constraints [4]. These inputs are used for developing the project detailed plans and milestones. Consistent process of gathering requirements at depths and breadth is essential to succeed in software projects since they go through many levels of translations from business requirements to technical requirements.

4.2 Defining requirements

The main reasons for variation in the estimation for time and budget in the software projects are related to the lack of complete understanding of the requirements properly. These gaps must be minimized at the time of requirements analysis so that the variations in required time and money to complete the project can be minimized. Source of customer dissatisfaction is also related to the lack of understanding the need. Specific requirements are defined and documented at the end of the analysis of the requirements. Requirements are categorized as functional, operational, interoperability and technical environment related requirements. The clients then look at the requirements and approve the requirements. The finalized document is called the Software Requirement Specification (SRS) which consists of all the software requirements that must be documented, planned, and tracked throughout the life cycle of the project.

4.3 Designing

Many technical design guidelines and standards are decided or reused from previous projects based on common software engineering principles. Fundamental software engineering concepts, such as abstraction, modularity, reusability, compatibility, extensibility, scalability, and maintainability are important aspects that are considered in design phase to develop the high quality and longer-lasting software solutions [2]. Level of modularity needed in the software is decided in the initial phase of the design to allow the level of flexibility for future changes. Furthermore, opportunities for code reusability, write once use many times, are also considered in the designing phase to increase efficiency and quality of the software product. Nonfunctional requirements such as compatibility, scalability, and maintainability are considered to make software more adoptable, change friendly.

In the designing phase of the workflow. The software architects plot the best architecture for the software to be developed using the SRS, that was developed in the previous step. To give a better context to the requirements, user stories or use cases are developed that would clarify interfacing requirements such as inter-functional inputs and output requirements. Software architects usually design one or more architecture and document it in the Design Document Specification (DDS). This document is further scrutinized with all the stakeholders with respect to the project boundaries, hazard evaluation, time imperatives and the financial plan.

4.4 Development

The actual development starts, and the software is built in this stage based on the DDS defined in the previous step the programming code for the software solution is generated. Various requirements and related user stories are itemized and coordinated within distributed and parallel development groups. With such approach programming and application development process, unknowns are minimized, and development become more efficient and effective. During the generation of the code, the developers follow organization wide coding standards and programming tools needed for the programming such as the interpreters, compilers, and debuggers [5]. Even though there are separate dedicated measures for testing and quality assurance, unit testing is performed at this stage to detect and address defects at the unit level. Unit testing is performed to ensure that an application or a product meets its design and behaves as per the requirements. These tests are run by the developers in their development environment. The developers test the internal logical structure of each software component as well as the individual function or procedure.

4.5 Testing and quality assurance

Software Testing is performed to detect the defects in the product while quality assurance process addresses the need for preventive measures to avoid the defects in the product. Quality Assurance measures ensure that the developed solution addresses all the requirements as defined in agreed specifications, standards, and functionality without known bugs, defects, or abnormal behaviors [6].

Software solution is tested from various perspectives before deployment for detecting defects and bugs. The defects, bugs, and abnormal behaviors in the software are discovered, tracked, fixed, and retested until the software reaches the quality requirements, that are characterized in the SRS.

Various types of tests conducted during this phase are integration testing, regression testing, software security testing, and user acceptance testing. Functional testing focuses on the functional requirements and software behavior in accordance with pre-determined requirements. Full set of functional inputs are used to validate the set of output it generates to affirm that all application functionalities work appropriately as indicated by the business requirements. Regression testing is performed to make sure previously developed, and tested application performs the same after making changes or enhancement in the application by retesting all functional and non-functional test cases. Integration testing is the part of programming testing where individual programming modules are amalgamated and tested overall to verify the coupling and interactions between them. Interface testing is conducted to make sure all human to software and all software-to-software interfaces are as per the requirements. Interface testing includes the UI testing, API testing, web services testing. Finally, the user acceptance testing is the last phase of testing in the software development life cycle where the business users or functional experts performs the acceptance testing to make sure the application meets all the customer requirements.

4.6 Deployment

Once the product is tested and ready to be conveyed, it is distributed and delivered to the end users. In this stage, various components of the software are packaged in a way that deployment checks the perquisites and then the components are sequenced, deployed, and verified. Various deployment mechanisms are decided and operationalized in this phase such as Manual (software is installed manually on the end points) v/s automated (software is installed automatically from centralized deployment systems), Push (software is pushed to targeted endpoints) v/s Pull (targeted endpoints may pull the software based on their preferences), Phased (deployment occurs in logically divided phases) v/s Big-Bang (app endpoints receive software at once). Subsequently, the maintenance, updates, and bug fixes are deployed using similar methods of deployment.

5. Workflow for software development management

There are many Software Development life cycle (SDLC) models that articulates series of steps, tasks, and dependencies for developing software [7]. Effectiveness of the model used for software development depends on many aspects such as requirements from users and developers, clarity and flexibility of scope changes, team size and dynamics, and need for interactions between stakeholders [8]. It is very important to consider time, cost, quality, product, risk, and resources while selecting and implementing software development model [1]. Software development models are very flexible and hence it is not necessary to stay within the bounds of each model. Various well recognized and followed models that can be modified and applied for the best results are as follows:

5.1 Waterfall model

The waterfall model is the oldest model for software development. The result of one stage can be inserted to the next stage successively in this model. Each phase is started only when the goals of the previous stage are achieved. Hence, the stages do not intersect in the waterfall model. The stages in this model are requirement analysis, System design, Implementation, Integration and Testing, Deployment of System and Maintenance. The waterfall model is straightforward. The stages are clearly categorized, and the processes and requirements are well archived. However, this model is not practical for modern complex and dynamic software development projects due to its lack of flexibility for accommodating changing requirements.

5.2 V-model

The V-model is called the verification and validation model where the execution of cycles occurs in a successive way in V-shape [1]. This model is an expansion of the waterfall model in which each testing stage is related with the subsequent development stage. The upside of V-model is that it is straightforward. However, this model is not that flexible to change as the changes are common in the dynamic world. In this model, the stages are completed in turns with verification and validation for that specific stage. One of the biggest benefits of this model is that defects are found and resolved at the early stages, which saves time later. This model functions well on modest activities where requirements do not change and are surely known. Each stage has a particular output to audit the process.

5.3 Iterative model

In this model, the implementation of a small set of requirements is done initially. In turn, iteratively, all the remaining requirements are implemented until the complete system is implemented and the software is ready to be deployed. Here, advancement starts by executing a piece of the software product that is needed to recognize the future necessities. A similar cycle is rehashed to create another form of the product toward the end goal. At every iterative cycle, the changes for the plan are developed and new functionalities are delivered. Henceforth, the basic idea of the iterative model is to foster the product through iterative cycles and incremental portions all at once. The iterative model is well suited when the requirements have interdependencies and they become clear with time and intermediate results. It is also well suited for large or long projects where requirements can be prioritized, and system can be functional with only partial requirements and products can be delivered in iteration effectively reducing the time to market.

5.4 Spiral model

The spiral model is an amalgamation of the ideas of an iterative model and waterfall model. In this model, the team addresses the requirements with incremental releases of the software through iterations around the spiral effectives decreases pending requires to be addresses in future pending spiral iterations. Instead of predefined set of requirements for each iteration and development stages, the spiral model is designed to empower development teams to select the most appropriate approach given the current goals, constraints, and risks [9]. Furthermore, the number of spiral iterations and requirements addressed in each iteration are not fixed and hence, the model allows additional flexibility to the development teams for take the most appropriate course of actions based on situation. Decreasing number of pending requirements with each iteration creates a spiral effect. Spiral model-based development can be effective in a variety of situations such as varying level of risks, project length, scope changes, as well as financial resources.

5.5 Agile model

This model is a mix of iterative and spiral process which centers around the versatility of the software and the satisfaction of the customers so that the software can be delivered at the quicker rate. Agile models are people-centric, recognizing the value competent people, and their relationships bring to software development [10]. In addition, it focuses on providing high customer satisfaction through efficient delivery of high-quality software, active participation of stakeholders, and continuous change [11]. This model allows breaking the software into small incremental modules for each iteration. Each iteration of the product lasts for the short term, typically less than a month, where development teams work with stakeholders on aspects such as planning, requirement analysis, design, coding, and testing simultaneously [10]. The working software is tested and demonstrated to the clients and stakeholders as a final step of each iteration. The agile model helps development teams divide the software into small modules that can be built within small timeframe and delivers specific high-quality deliverables for every release cycle. Agile model is one of the most effective methodologies for collaborative organizations.

5.6 RAD model

The Rapid Application Development model requires no preparation and development depends on prototyping and iterative turn of events. This model is very collaborative in nature where the information related to requirements and use cases are gathered from the customers through workshops and focus groups using the iterative concepts or reusing the existing prototypes. Here, the functional models are developed as prototypes and further development efforts are coordinated leading to the final product. Since no pre-planning processes are required, it is easy to include the changes in the software development process in iterations. The advantage of using this model is that the prototypes can be delivered, reused, and improved in stages. RAD model is aimed at speeding software development process. There are many RAD based implementations such as extreme development (XP) where business champion and developers lead efforts in increments, Join Application Development (JAD) where customers, end users, and developer work together in workshops, Lean Development (LD) where requirements are kept lean to include only minimum or must-have functionalities, and Scrum where software is developed in multiple short iterations.

6. Roles and responsibilities

Models discussed in previous section are not the complete list and they are not used exactly as they are described however the practical approach may match most of the framework of a specific model. There is proliferation of SDLC models due to many unique dependencies and varying demands of applications. However, to be successful regardless of the model used, clear role and responsibilities need to be defined. These roles and responsibilities are assigned to different groups of people based on which model is being used for software development. Common roles and responsibilities of people involved in Software Development and Management process is outlined in this section (Table 1) [12]:

Roles	Responsibilities
Project Sponsor	Provide governance framework for the project team Provide Budget and Requirements Approve project charter and overall timeline Review project progress periodically Direct management team if/as needed
Project Manager	Supervise the activities of all the project teams Manage risks and risk mitigation efforts Manage tactical changes in scopes and schedule as/if needed Manage the financial resources and timeline Allocate tasks and resources Provides status updates to stakeholders and customers. Develops the software project plan Ensured that delivery on time and within budget Determine phases and milestones of the project Implement effective project management methodology
Subject Matter Expert	Provide technical leadership with expertise in SDM Lead with knowledge of the discipline and technology Translate the business requirement into technical requirements Provide recommendations for improvements. Decide and implement most effective SDLC model
Product Owner	Represent the business and end-users Work closely with the user group to understand the requirements needed for the release. Prioritize the backlog during the development Make requirements decision to maximize the return on investment Make user acceptance and production release decisions
Technical Lead	Translates the business requirements to technical solutions. Lead the software developers and propose the solution. Communicate the status of the development efforts and challenges Establish discipline within the software development team. Provides solution and support for escalated challenges and technology risks
Software Developer	Develop the solution addressing the technical requirements Resolve or escalate development challenges and risks Integrates the software components by developing effective and efficient software programs Resolve bugs and errors or provides work arounds as needed
Software Tester	Test and ensure that the results meet the business requirements, and the results are free of bugs and errors Create the test plans, designs, test cases, and test data Make the success/failure decision based on test specifications, defect reports, and the test results Execute all types of tests such as system testing, regression testing and integration testing

Table 1.

Roles and responsibilities for software development and management.

7. Newer approaches for software development and management

The Software Development and Management process can be enhanced to be more effective using advanced methods and technologies. Automations, collaborations, Security, Cloud, and Mobile platforms are few areas that are driving innovative ways of software development and management that are more effective [9, 13]. Some of the modern approaches are listed below:

7.1 Development and operations (DevOps) approach

DevOps means development and operations as a single unified approach for SDM with effective communication between development and operational team. DevOps process creates a work environment with development, testing, and operations are part of a continuous cycle. The DevOps process comprises - planning, coding, building, testing, releasing, deploying, using, and providing the feedback with monitoring by restarting the loop. In DevOps approach, the IT team writes the software that meets the user requirements, deploys, and runs optimally. DevOps approach extends the software development management cycle to include continuous monitoring and continuous improvement.

DevOps ideas is now extended to include security to make it DevSecOps where the idea is to integrate security as part of development and operations workflows. DevSecOps mandates that security should be a key component of the application development pipeline since risk of security incidents related to the code vulnerabilities are becoming very costly [14]. Security is integrated in each step of the workflow. DevSecOps include security by providing the Secured Development Environment, including secure coding practice, static and dynamic security testing, and continuous monitoring the operational environment to identify and reporting security challenges.

7.2 Optimizing the workflow

The development teams usually follow the workflow that was established by the reference development model. However, it is uncertain that the previously selected workflow model works efficiently to develop the current software. Selection of the model must be analyzed periodically to identify slow stages and repetitive tasks, error prone processes, and variation in the quality of the software. Such indicators help to identify and resolve the internal management issues and can help in optimizing the workflow for the software development and management processes.

7.3 Improving the code quality and accuracy

The code quality and accuracy can be improved by allocating time for testing the software from the beginning. These goals can be achieved by using automated test cases and monitoring small fragments of the solution and making sure that we are progressing to develop the fundamentally sound software products. Even though, implanting such testing steps, widen the software development process since such tests are performed automatically, it improves quality of software products without slowing down the overall process. Many functional, non-functional, security, and technology related tests can be included to improve accuracy and quality of the code while being developed.

7.4 Cloud based Software development

The cloud-based information technology services have become a new platform for developing modern software applications that can run on advance platforms such as serverless computing. An early movement toward using web environments for application development came from companies that delivered software products as a service [15]. Software development and management decisions are made early not only to implement development and management methodologies but selection of development environment as cloud friendly programming languages, serverless coding, continuous integration, and continuous delivery mechanisms.

Another developing area of software development is Low-Code/No-Code (LCNC) software development. LCNC approach is based on automated no-code tools allowing used use develop application based on configuration driven, APIs based, cross-platform in cloud-based application development [16]. Many integration points and custom requirements still require low code development however underlying assumption is that many software building blocks are readily available from the cloud vendors or opensource that enables software development to be No Code or Low code effort. NCLC is still evolving field and hence the LCNC based solutions are very generic and tend to create bulky code that lacks runtime efficiency [C]. As a result, NCLC based software development cycles still needs code optimization and review to make it more efficient and through testing.

7.5 Continuous practices – integration (CI) and delivery (CD)

Modern application development and management practices need to devote significant resources to developing and delivering high-quality software at a faster rate [2]. Continuous Integration (CI) and Continuous Delivery (CD), referred to as continuous practices, are modern SDM practices aimed at assisting organizations in accelerating the development and delivery of software features without sacrificing quality. While CI encourages integrating work-in-progress numerous times a day, CD is concerned with the capacity to release values to consumers rapidly and reliably by including as much automation as feasible. CD includes the deployment to the live environment without human intervention.

Continuous integration is a software development practice where multiple members of a development team work on a various branch of the software simultaneously and use a version control system to frequently integrate their work to the main branch [17]. Each change is built and verified to detect integration errors as quickly as possible. Continuous delivery is a software development methodology where the release process is automated. Every software change is automatically built, tested, and deployed to production. Before the final deployment and delivery, a person, an automated predefined test, or a business rule decides when the final push should occur [17]. Security weaknesses and vulnerabilities can pass undetected through oversights and mistakes in programming and testing, making code susceptible to vindictive activity. Thus, security best practices we discussed so far should be a part of the CI/CD pipelines by using weakness checkers and as separate additional security checks during the testing system. CI/CD required test automation tolls and deployment automation tools. Test automation tools are used for continuously unit, functional, and performance testing when any change is introduced in the code to ensure the stability of the code base [18]. Similarly, for Delivery and deployment, automation tools are used for packaging and integrating code changes in the live environment at much faster rate without any human intervention and by adhering to all preprogrammed and automated business rules [18].

Continuous practices have few benefits such as receiving more and faster feedback from the software development process and customers; [19] having frequent and reliable releases, which leads to improved customer satisfaction and product quality; and [17] strengthening the connection between development and operations teams and eliminating manual tasks [20, 21]. Continuous practices are making inroads in software development industrial practices across diverse domains and sizes of enterprises. Adopting continuous practices, on the other hand, is not a simple undertaking since organizational processes, practices, and tools may not be prepared to support the very complex and hard nature of these practices [22].

8. Conclusion

Ensuring that high quality systems are delivered, assisting the projects by using strong management controls, and maximizing the productivity of the team members are the primary objectives of software development and management. To meet these objectives, the requirements, which are needed are: supporting the project teams of the various scopes and types, assisting the technical and the management teams, providing guidance of how to install the software which is needed for the development of the software. The technical activities include analyzing, designing, coding, testing, installing the software’s and defining the technical strategy of the project. The management activities include defining the project objectives, tracking the progress of the project, reporting the project status, risk assessment, quality assurance and user interaction post implementing the software. Hence, to meet all these objectives and requirements many software models are used. These models have a layered approach to analysis, design, installation, and support. It also explains how the software must be developed by creating tasks, getting the right deliverables, and organizing the resources where they can be quickly accessed. Defining and selecting the software models should be taken up and managed with appropriate levels of expertise. So, the software development and management constitute the culture of the software teams and how the development process is planned, managed, and executed in a professional manner.