General Overview of PSP

General Overview of PSP

PSP (The Personal Software Process) refers to an organized software development process designed to help software engineers in utilizing sound practices in engineering (Raza & Faria, 2016). PSP assist software engineers in planning and tracking their projects with the use of the defined and measured process, establishing goals, and tracking their performance against the set goals. Through the application of PSP, engineers can comfortably manage the quality of software from the beginning of a project to accomplish. Besides, the PSP allows its users to analyze the results of each task and use results obtained to advance the software process of the subsequent project. Also, PSP focuses more on the performance of individual users and proceeds to improving the process of working engineers. Fundamentally, the principle behind the PSP is facilitating the production of quality software systems. Therefore, every engineer engaged in the process network must perform exceptionally.

Goals of PSP

One of the goals of PSP is to improve the software engineers estimating and planning skills. In the software development process, engineers should have a timeline in which the process is expected to be complete. Besides, each activity within the development process should be assigned to an individual and specific schedule to be allocated for the completion of the assigned task. Through PSP, engineers can estimate the time in which each and the overall responsibility will be complete. This involves planning the entire software development process to avoid the inconvenience that might result due to poor planning.

Another goal of the PSP is to minimize the number of defects in the process of software development. In the software development process, defects entail a bug or an error in the application being developed. Programmers, while building and designing the software, can make an error or mistake (O’Regan, 2017). PSP can assist in minimizing defects as it helps developers in how to make a sound plan, quality of the product, and making a commitment towards the process. Also, PSP offers developers a chance to evaluate the work they have done and suggest ways of reviewing and analyzing the data to minimize defects.

PSP aims at assisting individual engineers in improving their performance gradually. Overall, PSP is designed to help own engineers to advance in personal achievement, whether at individual levels or when working within a team. PSP aims at instilling discipline to software engineers in terms of developing the products and tracking the forecasted and actual code development. Moreover, PSP assists engineers on how to make plans and be committed to the programs to improve their performance.

Most Important Practices in PSP

The first essential practice in PSP is the introduction of discipline and measurement often denoted by PSPO. It is composed of three phases, including planning, development, and assessment. The notion behind the process is putting in place the current method measuring including an estimated timeline of programming, investigating faults removed or injected, and determining the size of the program. At the assessment stage, software engineers ensure all the intended data have been recorded and analyzed. This process is essential in PSP as it provides the coding standard has been met, ze measured, and personal process improvement plan developed.

The next process in PSP introduces estimating and planning, often referred to as PSP1. Basing on the data collected in the first process of adding discipline and measurement, the software engineers can determine the size of the new program and make a test report. Data obtained from the projects that have been done before are useful in making the estimates of the required time. The information collected can be used further in the planning of tasks and schedules as well as estimation.

The final process introduced quality management and design marked by PSP2. The process is of significance to code review and design review. Removal and prevention of possible defects are associated with this process. Software engineers realize how to measure the time taken by conducting a task and specific errors they remove or inject from each phase in the development process (Rong et al., 2018). Besides, this process introduces analysis techniques and design specifications. Many software developers have appreciated quality management and design across many companies. Other than assisting in the realization of quality software, the practice assists engineers in learning new concepts regarding other software developments. This is because skills gained from one method can be transferred to other operations.

Most Positive Practice: Introduction of Quality Management and Design

This process is most important as it ensures that the software program developed meets the expected standards. The leading practices under this process entail design and code review. The review process ensures that the defects and errors made during the development process are corrected. Besides, each phase of the development process is reviewed under this process to assess whether all the specifications have been met. The method also allows software engineers to use a checklist to discuss the design and codes to ensure all aspects of the design process are covered.

Positive Impacts of Introduction of Quality Management and Design and Making it Beneficial

Regarding software quality, the introduction of quality management and design ensures that the software developed is of high quality and meets the desired standards. The engineers participating in the software development provides improvement of the process through assessing the defects made at each stage and deliver the errors are removed. Mistakes are common occurrences in the software engineering process. Such defects may interfere with the overall intended design. Through quality management and design, engineers can trace the flaws and correct; hence, realizing quality. Subsequently, code and design reviews ensure that the quality desired is achieved.

Quality management and design also create a positive impact regarding timelines used in developing a software program. Since PSP aims at improving the performance of each engineer engaged in the process, through quality management and design, each engineer is likely to work efficiently, leading to a faster development process that is error-free. Also, quality management and design ensure that errors are addressed at each stage of the software development process. This aspect reduces the time that would have been taken to start over the development process again.

Quality management and design impacts positively on customer and workplace satisfaction. In this view, the process aims at the realization of the desired quality in the production process. Customers often focus on the quality and effectiveness of the software developed; hence, satisfaction. Concerning the workplace, quality management, and design minimizes wastage of time in the design process and retains customers for the organization.

The introduction of quality management and design can be made more beneficial to an organization by conducting quality and design assessments at each stage of development. After each step, the engineers should evaluate the presence of any errors and address such errors to prevent further damage. Moreover, quality management and design at each stage would ensure the stakeholders present their input in case some adjustments are required.

Least Beneficial Practice: Introduction of Estimation and Planning

This process aims at estimating the time the entire project of particular tasks will take. The process requires engineers to obtain data from previous projects that have been completed to use in determining the time the current plan is likely to take (Qureshi, 2014). Moreover, such information from the previous projects is used for the planning of tasks and schedules. This process of PSP seems to be least beneficial since software development varies from one to another. Also, they differ in complexity and timelines required to complete, as well as the resources needed. Therefore, it seems unrealistic to use the estimation of previous projects as likely indicators of the present one.

Negative Impacts of Introduction of Estimation and Planning and Making it Beneficial

The introduction of estimation and planning may harm the software quality developed. Based on the evaluation, the software team may rush to complete a project to meet the projected timelines. As a result, some essential steps may be overlooked to keep with the deadlines leading to poor quality.

The estimation might also lead to a delay in the completion of a task. In the case of a job that can take a shorter time, the estimated time may suggest that the task will take longer. The developing team may not work actively to meet the deadlines. Thus, each task should be treated separately, as they often have unique requirements.

Concerning customer and workplace satisfaction, planning based on estimation might lead to poor quality of product development as well as delays in the production process. Since customers prefer goods of high quality, rushed or delayed products may least satisfy them. Ultimately, the organization will lose customers minimizing their profits.

The introduction of estimation and planning can be made more beneficial to an organization by ensuring that similar tasks are grouped and using the estimates from those tasks to plan for the current or future tasks. This aspect will ensure that the quality of a task is not compromised by comparing it with a different one. Specifically, the team conducting software development should ensure that related tasks are grouped to facilitate ease at which the following functions are performed.

Question 2: Focus on Agile Process

General Overview of XP

XP (Extreme Program) refers to an agile software development framework designed to offer improved software quality, and higher life quality of the team undertaking the development (Plonka, 2014). Of all the agile frameworks, XP is considered as the most appropriate engineering for the development of software. Different elements define XP. Some of these elements are programming in pairs or undertaking extensive review of codes, unit testing of all code, preventing programming of parts before they are needed, code clarity and simplicity, a flat management structure, understanding the changes in customer’s needs over time, and facilitating communication between an organization and customers among other programs. XP was developed by Ken Beck, a software engineer in the 90’s. The objective of improving the software was to realize ways of producing high-qualitative software faster and with the ability to adapt to the changing needs of customers. XP is specifically designed for the practice of engineers. It enables software designers to exceed their capabilities while undertaking their duties. From that sense, the name extreme was associated with the software program.

Values and Principles of XP

One of the universal benefits of XP is communication. Communication plays a vital role among the team undertaking software development. In this sense, members of the development team have to transfer critical information that facilitates the successful completion of the software designs (Usman, Soomro, & Brohi, 2014). The specific forms of communication that are often used among the software developers include face to face, discussion through the use of the whiteboard, or drawing mechanisms.

Another value of XP is simplicity. The concept of simplicity answers the question of what specific item or model that will lead to the desired results? The notion behind simplicity while developing software programs is to undertake only essential actions and avoid waste. This may entail making a system as simple as possible to enhance the ease to which it can be maintained, supported, or revised should need be. Moreover, the idea of simplicity focuses on the requirements the team is aware of and does not include future possibilities.

Advantages and Disadvantage of Extreme Programming

One of the pros of XP is making operations fast. Compared to the past years and other methods of developing software, XP projects often last for just a few months. With the program in place, work environments are a fast-paced reducing time for wastage. Moreover, XP has facilitated continuous deployment and integration among the team involved in developing the software program.

XP also assists individuals and organizations in cost minimization while making a software program. In extreme programming, the loop regarding feedback is minimized. Therefore, the cost of shifting is also lessened. Other methodologies seem less appealing because they can be redesigned only after evaluation by the customers. In XP, modifications can be made across the design process.

On the other hand, XP possesses certain disadvantages. One of the problems is that code overcomes design. XP focuses on the system rather than the design. Often, applications are sold based on the map, as a result, the customer may not be pleased with the final product in case the design is not perfect. At times, the focus on code might lead to failure in full implementation of the requirements of the software.

Most Important Practices in XP

There are different XP practices currently used and essential in the software development process. One of the fundamental methods is pair programming. It is considered as one of the unique XP traits and involves two or more engineers working together to create a code. Those some companies value the technique; the approach requires careful choice of partners to realize maximum effectiveness. Traditionally, there is a need to train the people at leadership positions who underestimate the value of pairing and consider it as an increased cost or overhead.

Another essential practice is planning games. Much of the credit often attributed to XP is the notion that it introduced a unique approach to planning work through organizing small batches of work regularly while utilizing a steady schedule. The idea became a precursor to what was known by many people as “Iteration Planning” or “Sprint Planning” and today related to Scrum or other Agile processes. Planning iteratively and using a widely recognized technique known as “user stories” IS regarded as one of the essential XP aspects that reduce to Scrum, the most popular method in Agile in the current world.

A continuous process is also an essential practice in XP. In the process of software development using the agile process, codes are regularly integrated and releasing the code on a cadence. In the recent past, the practice has become more accessible by a movement referred to as “DevOps,” a concept that initiated the XP practice (Bougroun, Zeaaraoui & Bouchentouf, 2014). Creating codes iteratively and releasing often enhances a team to assess product state and address issues early enough before much damage, a practice that enhances the high quality of software at the end.

Moreover, test-driven development (TDD) forms an essential practice in XP. XP suggests that it is necessary to record unit tests before code, a method that is often assumed by many organizations. TDD is essential as it enhances the quality of code as it requires checks to be in writing, which signifies that code must meet requirements before it is forwarded and integrated to the works of other members in the team.

Most Positive Practice: Continuous Process

A continuous process is the identified most crucial practice in the XP process. It is composed of three sections; continuous integration, design improvement, and small release. First, the concept of constant integration proposes that the designers should always focus on the newest type of software (Eck, Uebernickel & Brenner, 2014). Because different teams or individuals involved in the process may have different versions with various improvements and changes, it is essential to attempt to upload the current version to the respiratory code often or when a significant break is evident. Continuous integration will ensure that there is no delay as the project proceeds that might have been caused by problems of integration. Design improvement, an aspect of XP’s continuous process, suggests that programming should be restricted to only what is necessary at that specific time, ensuring the implementation is as simple as possible. Finally, small release ensures that delivery of the software is conducted through version in little bits leading to the creation of constant value. The short version makes the customer have confidence in the progress of the project. A continuous process is essential in the software development process as corrections can be done ones they are realized; hence, reducing the cost of restructuring after completion.

Positive Impacts of Continuous Process and Making it More Beneficial

The continuous process as a practice in XP has many benefits to the stakeholders and activities. First, the ongoing process ensures the realization of high-quality software. In this view, the current process makes it possible for engineers engaged in the software development process to regularly integrate codes to ensure that the best one moves to the next stage. The state of the product being developed is also assessed at each stage, and any error realized is corrected. As a result, the software developed is often of high quality.

Regarding timelines, the continuous process presents many advantages to the team developing the software. One essential aspect of the constant process as a practice in XP is planning for each stage and assigning groups to perform each task within the given timelines. Due to the planning aspect, jobs are often completed in time. Also, the continuous process allows for correcting mistakes at each stage, which takes a shorter time compared to tracking the errors after completion of the software development.

Continuous process practice also enhances the level of satisfaction of customers. One aspect of the ongoing process is a small release. In this regard, the system developers can release software progress frequently to the customers. As a result, the customers often gain confidence in the software development process and can suggest desired changes before the process is complete, leading to increased satisfaction. Also, through the appreciation of customers, the organization benefits as it earns customer’s loyalty.

The continuous process can be made more beneficial by influencing all the stakeholders in an organization to appreciate it. It this view, the organization will put in place a communication framework that facilitates continuous feedback not only within the developing firm but also among the stakeholders. As a result, constant process practice will work effectively.

Least Beneficial Practice: Pair Programming

Pair programming practice is considered as one of the unique traits of XP but is not widely accepted by many organizations undertaking software development. It refers to the method in which two engineers or more groups are paired to make a given program. This practice aims to ensure that a high-quality program is developed through brainstorming and sharing ideas between individuals and teams (Weber, 2016). In developing the codes among the group, careful selection is required to ensure compatibility among individuals working together. The process seems to be complicated and presents minimum benefits to an organization as it slows the process of developing software due to time is taken for consultations and often results in conflicts.

Negative Impacts of Pair Programming and Making it More Beneficial

Pair programming has a different negative effect. One of the adverse consequences is that it might lead to a poor quality of software developed. This is because assigning teams or individuals with equal input on the codes being developed might lead to diversion from the original plan due to the diverse views that arise on what should be done. Also, disagreements that often occur in what should be done and by who may lead to failure of a project with no one taking responsibility.

Concerning timelines, engaging people to work in pairs will slow down the process of software development. This is because much time will be taken on discussions on the best way to do the cording that is suitable for the entire team. If the process were to be done by a single individual, there would be no much time for discussions but just to strictly follow the design.

Pair programming might also lead to less customer satisfaction. This is because the disagreements in the process of designing the software when people work as a team may extend to the customer. It is a common belief that differences often lead to poor quality of products. The customer perception would be that the software developed does not meet expectations. Also, since the pairing process takes time, the customer may be forced to wait for long before receiving the product. Moreover, the organization can experience a loss of customers, especially those who are not satisfied with the process of developing the software program.

Pair programming can be made more beneficial to an organization through pairing engineers but having one leader in each pair. Even though they will work together and discuss how to move forward, the leader will have the ultimate say in designing the program. Through the creation of the hierarchy, the least time will be spent on arguments; hence, making the process of software development fast.

References

Bougroun, Z., Zeaaraoui, A., & Bouchentouf, T. (2014, October). The projection of the specific practices of the third level of CMMI model in agile methods: Scrum, XP, and Kanban. In 2014 Third IEEE International Colloquium in Information Science and Technology (CIST) (pp. 174-179). IEEE.

Eck, A., Uebernickel, F., & Brenner, W. (2014). Fit for continuous integration: How organizations assimilate an agile practice.

O’Regan, G. (2017). Software process improvement. In Concise Guide to Software Engineering (pp. 239-254). Springer, Cham.

Plonka, L., Sharp, H., Gregory, P., & Taylor, K. (2014, May). UX design in agile: a DSDM case study. In International Conference on Agile Software Development (pp. 1-15). Springer, Cham.

Qureshi, M. (2014). Estimation of the new agile XP process model for medium-scale projects using industrial case studies. arXiv preprint arXiv:1408.6228.

Raza, M., & Faria, J. P. (2016). A model for analyzing performance problems and root causes in the personal software process. Journal of Software: Evolution and Process, 28(4), 254-271.

Rong, G., Zhang, H., Liu, B., Shan, Q., & Shao, D. (2018). A replicated experiment for evaluating the effectiveness of pairing practice in PSP education. Journal of Systems and Software, 136, 139-152.

Usman, M., Soomro, T. R., & Brohi, M. N. (2014). Embedding project management into XP, SCRUM, and RUP. European Scientific Journal, 10(15).

Weber, E. V. (2016). Performance Learning of Agile Methodology Using Paired Courses of Systems Analysis and Design and Web/Mobile Programming. In Proceedings of the EDSIG Conference ISSN (Vol. 2473, p. 3857).