The two main things the Agile Manifesto did was to provide a set of value statements that form the foundation for Agile software development and to coin the term Agile software development itself. In the months afterward, the authors expanded on the ideas of the Agile Manifesto with the 12 Principles Behind the Agile Manifesto. Agile Software Development, Principles, Patterns, and Practices: Pearson New International Edition 1st (first) Edition by Martin, Robert C. Published by Pearson (2013). There are 12 agile principles outlined in The Agile Manifesto in addition to the 4 agile values. These 12 principles for agile software development help establish the tenets of the agile mindset. They are not a set of rules for practicing agile, but a handful of principles to help instill agile thinking.
Why were Agile Methodologies developed?
Agile methodologies were developed as a solution to the challenges of the traditional waterfall model of software development and the traditional project and team management principles. They started as software development approaches but later evolved into methods of managing teams and projects. In general, the shift in agile methodologies entails giving more weight to individuals and interactions over processes and tools, emphasis on working software over comprehensive documentation, focus on customer collaboration over contract negotiation and valuing responsiveness to change rather than the following of a plan.
Business Analysts, Project managers and Software developers ought to familiarize themselves with Agile methodologies because they are becoming popular, especially in mid-sized and small organizations. Even PRINCE2 methods are being enhanced to accommodate Agile methodologies.
In 2001, 17 software developers met in Utah and developed The Agile manifesto, which has twelve core principles. From these core principles, several Agile methodologies have emerged and they include Scrum, unified process, dynamic systems development method (DSDM), crystal clear, extreme programming (aka 'XP'), adaptive software development and feature-driven development. And new flavours continue to emerge.
From Beck, Kent et al. (2001), below are the twelve core principles of the Agile Manifesto:
1. Customer satisfaction through early and continuous delivery of useful software
Customer satisfaction is obtained through early delivery of products to customer for testing and feedback, through continuous delivery to let customer know the progress and through delivery of values to the customers by fulfilling the top priority requirements first. The output of each iteration is working code that can be used to evaluate and respond tochanging and evolving user requirements.
2. Welcome changing requirements, even late in development
This places emphasis on responsiveness to change as opposed to tight alignment to approved plans. The change control process is simplified and no formal documentation and approval required. This is harness change for the customerâs competitive advantage because it allow fast response to latest changes in external environment to enhance competitive advantage to emerging opportunities.
3. Frequently Delivered Software(weeks rather than months)
This provides immediate values to the customers by delivering working features. Each iteration or Sprint should lead to a release of a product. The teams make sure that each feature is fully developed, tested, styled, and accepted by the product owner before counting it as delivered. The project team activities can be better structured with the fixed delivery timeframe to focus on delivery of value.
4. Close, daily cooperation between business people and developers
Agile development principles include keeping requirements and documentation lightweight, and acknowledging that change is a normal and acceptable reality in software development. This makes close collaboration particularly important to clarify requirements just-in-time and to keep all team members âon the same pageâ throughout the development.
5. Projects are built around motivated individuals, who should be trusted
Projects are built around motivated individuals who are given the environment and support they need, and trusted to get the job done. Team members choose the jobs they are most interested in through self-organization and not through external management influence. Micromanagement and top-down approach to management are shunned.
6. Face-to-face conversation is the best form of communication
Obtain direct feedback by going to the source of problem or confusion and use oral communication at the workplace for the benefit of osmotic communication. Virtual team conversations are facilitated via video conferencing.
7. Collocation and pair programming
This principle is practiced via colocation and pair programming. Collocation involves collocating a number of teams in the same open area and pair programming, which entails two programmers sharing a single workstation (one screen, keyboard and mouse). The programmer at the keyboard is usually called the 'driver', the other, also actively involved in the programming task but focusing more on overall direction is the 'navigator'; it is expected that the programmers swap roles every few minutes or so.
This leads to increase in code quality because 'programming out loud' leads to clearer articulation of the complexities and hidden details in coding tasks, reducing the risk of error or going down blind alleys. It also yields better diffusion of knowledge among the team. Other benefits include better transfer of skills, large reduction in coordination efforts, and improved resiliency of a pair to interruptions.
8. Sustainable development, able to maintain a constant pace
Agile methodologies seek work-life balance among the team members and promote happiness by avoiding burnout or exhaustion. Through close collaboration and by being alert and creative, these methodologies avoid long nights and weekends, during which people try to undo the errors of unresponsive planning. The sponsors, developers, and users are able to maintain a constant pace indefinitely.
9. Excellence through Reflection
The best architectures, requirements, and designs emerge from self-organizing teams. At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly. These retrospective meetings ensure that the lessons learned during the project are put back into the next iteration.
10. Simplicityâthe art of maximizing the amount of work not doneâis essential
The Pareto principle or the 80/20 rule is applied. It means that typically 80% of your results may actually come from only 20% of your efforts! The idea is to focus on the important 20% of effort that gets the majority of the results. If you have control over the scope, and if speed-to-market is of primary importance, why not seek to deliver the important 80% of your product in just 20% of the time?
Focus on what are essential to create value to the project and customer not on distractors that do not add values like components, process, etc.
11. Self-organizing teams
The team is utterly self-managing under the Scrum methodology. It has autonomy and responsibility to meet the goals of the sprint and is responsible for determining how it will accomplish the work to be completed. The basic principle is that the team knows best how to carry out the work, not the project manager or human resources department.
12. Regular adaptation to changing circumstance
This is in contrast to capturing all known requirements and baseline the scope so that any other changes are subject to change control. Agile Development holds that that requirements emerge and evolve, and that however much analysis and design you do, this will always be the case because you cannot really know for sure what you want until you see and use the software. And in the time you would have spent analyzing and reviewing requirements and designing a solution, external conditions could also have changed.
Scrum is an agile process framework for managing complex knowledge work, with an initial emphasis on software development, although it has been used in other fields and is slowly starting to be explored for other complex work, research and advanced technologies.[1] It is designed for teams of ten or fewer members, who break their work into goals that can be completed within timeboxed iterations, called sprints, no longer than one month and most commonly two weeks, then track progress and re-plan in 15-minute time-boxed stand-up meetings, called daily scrums.[2][3]
Key ideas[edit]
Scrum is a lightweight, iterative and incremental framework for managing complex work.[4][5] The framework challenges assumptions of the traditional, sequential approach to product development, and enables teams to self-organize by encouraging physical co-location or close online collaboration of all team members, as well as daily face-to-face communication among all team members and disciplines involved.
A key principle of Scrum is the dual recognition that customers will change their minds about what they want or need (often called requirements volatility[6]) and that there will be unpredictable challengesâfor which a predictive or planned approach is not suited.
As such, Scrum adopts an evidence-based empirical approach â accepting that the problem cannot be fully understood or defined up front, and instead focusing on how to maximize the team's ability to deliver quickly, to respond to emerging requirements, and to adapt to evolving technologies and changes in market conditions.
Agile Software Development Principles Patterns And Practices 2013Capitalization of Scrum[edit]
Scrum is occasionally seen written in all-capitals, as SCRUM.[7] The word is not an acronym, so this stylization is not correct; it likely arose due to an early paper by Ken Schwaber[8] which capitalized SCRUM in its title.[2][9]
While the trademark on the term Scrum itself has been allowed to lapse, it is deemed as owned by the wider community rather than an individual,[10] so the leading capital for Scrum is retained in this article.
Many of the terms used in Scrum are typically written with leading capitals (e.g., Scrum Master, Daily Scrum). However, to maintain an encyclopedic tone, this article uses normal sentence case for these terms (e.g., scrum master, daily scrum) â unless they are recognized marks (such as Certified Scrum Master).
History[edit]
Hirotaka Takeuchi and Ikujiro Nonaka introduced the term scrum in the context of product development in their 1986 Harvard Business Review article, 'The New New Product Development Game'.[11] Takeuchi and Nonaka later argued in The Knowledge Creating Company[12] that it is a form of 'organizational knowledge creation, [..] especially good at bringing about innovation continuously, incrementally and spirally'.
The authors described a new approach to commercial product development that would increase speed and flexibility, based on case studies from manufacturing firms in the automotive, photocopier and printer industries.[11] They called this the holistic or rugby approach, as the whole process is performed by one cross-functional team across multiple overlapping phases, in which the team 'tries to go the distance as a unit, passing the ball back and forth'.[11] (In rugby football, a scrum is used to restart play, as the forwards of each team interlock with their heads down and attempt to gain possession of the ball.[13])
The Scrum framework was based on research by Schwaber with Tunde Babatunde at DuPont Research Station and University of Delaware. Tunde advised that attempts to develop complex product, such as software, that werenât based in empiricism were doomed to higher risks and rates of failure as the initial conditions and assumptions change. Empiricism, using frequent inspection and adaptation, with flexibility and transparency is the most suitable approach.
In the early 1990s, Ken Schwaber used what would become Scrum at his company, Advanced Development Methods; while Jeff Sutherland, John Scumniotales and Jeff McKenna developed a similar approach at Easel Corporation, referring to it using the single word scrum.[14]
Ken and Jeff worked together to integrate their ideas into a single framework, Scrum. They tested Scrum and continually improved it, leading to the 1995 paper, the Agile Manifesto in 2001, and the worldwide spread and use of Scrum since 2002.
In 1995, Sutherland and Schwaber jointly presented a paper describing the Scrum framework at the Business Object Design and Implementation Workshop held as part of Object-Oriented Programming, Systems, Languages & Applications '95 (OOPSLA '95) in Austin, Texas.[15] Over the following years, Schwaber and Sutherland collaborated to combine this materialâwith their experience and evolving good practiceâto develop what became known as Scrum.[16]
In 2001, Schwaber worked with Mike Beedle to describe the method in the book, Agile Software Development with Scrum.[17] Scrum's approach to planning and managing product development involves bringing decision-making authority to the level of operation properties and certainties.[2]
In 2002, Schwaber with others founded the Scrum Alliance[18] and set up the Certified Scrum accreditation series. Schwaber left the Scrum Alliance in late 2009 and founded Scrum.org which oversees the parallel Professional Scrum accreditation series.[19]
Since 2009, a public document called The Scrum Guide[16] has been published and updated by Schwaber and Sutherland. It has been revised 5 times, with the current version being November 2017.
Roles[edit]
There are three roles in the Scrum framework.[20] These are ideally co-located to ensure optimal communication among team members. Together these three roles form the scrum team. While many organizations have other roles involved with defining and delivering the product, Scrum defines only these three.[16]
Product owner[edit]
The product owner, representing the product's stakeholders and the voice of the customer (or may represent the desires of a committee[21]), is responsible for delivering good business results. [22] Hence, the product owner is accountable for the product backlog and for maximizing the value that the team delivers.[21] The product owner defines the product in customer-centric terms (typically user stories), adds them to the product backlog, and prioritizes them based on importance and dependencies.[23] A scrum team should have only one product owner (although a product owner could support more than one team)[24] This role should not be combined with that of the scrum master. The product owner should focus on the business side of product development and spend the majority of their time liaising with stakeholders and the team. The product owner should not dictate how the team reaches a technical solution, but rather will seek consensus among the team members.[25][better source needed] This role is crucial and requires a deep understanding of both sides: the business and the engineers (developers) in the scrum team. Therefore a good product owner should be able to communicate what the business needs, ask why they need it (because there may be better ways to achieve that), and convey the message to all stakeholders including the delivery Team using a technical language, as required. The Product Owner uses Scrumâs empirical tools to manage highly complex work, while controlling risk and achieving value.
Communication is a core responsibility of the product owner. The ability to convey priorities and empathize with team members and stakeholders is vital to steer product development in the right direction. The product owner role bridges the communication gap between the team and its stakeholders, serving as a proxy for stakeholders to the team and as a team representative to the overall stakeholder community.[26][27]
As the face of the team to the stakeholders, the following are some of the communication tasks of the product owner to the stakeholders:[28]
Empathy is a key attribute for a product owner to haveâthe ability to put one's self in another's shoes. A product owner converses with different stakeholders, who have a variety of backgrounds, job roles, and objectives. A product owner must be able to see from these different points of view. To be effective, it is wise for a product owner to know the level of detail the audience needs. The development team needs thorough feedback and specifications so they can build a product up to expectation, while an executive sponsor may just need summaries of progress. Providing more information than necessary may lose stakeholder interest and waste time. A direct means of communication is the most preferred by seasoned agile product owners.[24]
A product owner's ability to communicate effectively is also enhanced by being skilled in techniques that identify stakeholder needs, negotiate priorities between stakeholder interests, and collaborate with developers to ensure effective implementation of requirements.
Development team[edit]
The development team has from three to nine members who carry out all tasks required to build increments of valuable output every sprint.[23]
While team members are referred to as developers in some literature[16], the term refers to anyone who plays a role in the development and support of the system or product, and can include researchers, architects, designers, data specialists, statisticians, analysts, engineers, programmers, and testers, among others.[20] However, due to the confusion that can arise when some people do not feel the term 'developer' applies to them, they are often referred to just as team members.
The team is self-organizing. While no work should come to the team except through the product owner, and the scrum master is expected to protect the team from too much distraction, the team should still be encouraged to interact directly with customers and/or stakeholders to gain maximum understanding and immediacy of feedback.[23]
Scrum master[edit]
Scrum is facilitated by a scrum master, who is accountable for removing impediments to the ability of the team to deliver the product goals and deliverables.[29] The scrum master is not a traditional team lead or project manager but acts as a buffer between the team and any distracting influences. The scrum master ensures that the scrum framework is followed. The scrum master helps to ensure the team follows the agreed processes in the Scrum framework, often facilitates key sessions, and encourages the team to improve. The role has also been referred to as a team facilitator[30] or servant-leader to reinforce these dual perspectives.
The core responsibilities of a scrum master include (but are not limited to):[31]
Agile Software Development Sprint
The scrum master helps people and organizations adopt empirical and lean thinking, leaving behind hopes for certainty and predictability.
One of the ways the scrum master role differs from a project manager is that the latter may have people management responsibilities and the scrum master does not. A scrum master provides a limited amount of direction since the team is expected to be empowered and self-organizing.[33] Scrum does not formally recognise the role of project manager, as traditional command and control tendencies would cause difficulties.[34]
Workflow[edit]Sprint[edit]
Scrum framework
The Scrum process
A sprint (also known as iteration or timebox) is the basic unit of development in Scrum. The sprint is a timeboxed effort; that is, the length is agreed and fixed in advance for each sprint and is normally between one week and one month, with two weeks being the most common.[2]
Each sprint starts with a sprint planning event that establishes a sprint goal and the required product backlog items. The team accepts what they agree is ready and translate this into a sprint backlog, with a breakdown of the work required and an estimated forecast for the sprint goal. Each sprint ends with a sprint review and sprint retrospective, that reviews progress to show to stakeholders and identify lessons and improvements for the next sprints.[14]
Scrum emphasizes valuable, useful output at the end of the sprint that is really done. In the case of software, this likely includes that the software has been fully integrated, tested and documented, and is potentially releasable.[34]
Sprint planning[edit]
At the beginning of a sprint, the scrum team holds a sprint planning event[35] to:
Daily scrum[edit]
A daily scrum in the computing room. This centralized location helps the team start on time.
Each day during a sprint, the team holds a daily scrum (or stand-up) with specific guidelines:
Any impediment (e.g., stumbling block, risk, issue, delayed dependency, assumption proved unfounded)[36] identified in the daily scrum should be captured by the scrum master and displayed on the team's scrum board or on a shared risk board, with an agreed person designated to working toward a resolution (outside of the daily scrum). While the currency of work status is the whole team's responsibility, the scrum master often updates the sprint burndown chart.[37] Where the team does not see the value in these events, it is the responsibility of the scrum master to find out why.[38] This is part of the responsibility of educating the team and stakeholders about the Scrum principles.[32]
No detailed discussions should happen during the daily scrum. Once the meeting ends, members can (usually two or more) get together to discuss issues in detail and some call this as 'breakout sessions' or 'after party'.[37]
Sprint review[edit]
At the end of a sprint, the team holds two events: the sprint review and the sprint retrospective.
At the sprint review, the team:
Guidelines for sprint reviews:
Sprint retrospective[edit]
At the sprint retrospective, the team:
Guidelines for sprint retrospectives:
Backlog refinement[edit]
Backlog refinement (formerly called grooming) is the ongoing process of reviewing product backlog items and checking that they are appropriately prepared and ordered in a way that makes them clear and executable for teams once they enter sprints via the sprint planning activity. Product backlog items may be broken into multiple smaller ones. Acceptance criteria may be clarified. Dependencies may be identified and investigated.
Although not originally a core Scrum practice, backlog refinement has been added to the Scrum Guide and adopted as a way of managing the quality of product backlog items entering a sprint, with a recommended investment of up to 10% of a team's sprint capacity.[16][39]
The backlog can also include technical debt (also known as design debt or code debt). This is a concept in software development that reflects the implied cost of additional rework caused by choosing an easy solution now instead of using a better approach that would take longer.
Cancelling a sprint[edit]
The product owner can cancel a sprint if necessary.[16] The product owner may do so with input from the team, scrum master or management. For instance, management may wish the product owner to cancel a sprint if external circumstances negate the value of the sprint goal. If a sprint is abnormally terminated, the next step is to conduct a new sprint planning, where the reason for the termination is reviewed.
Artifacts[edit]Product backlog[edit]
The product backlog is a breakdown of work to be done[40] and contains an ordered list of product requirements that a scrum team maintains for a product. Common formats include user stories and use cases.[34] The requirements define features, bug fixes, non-functional requirements, etc.âwhatever must be done to deliver a viable product. The product owner prioritizes product backlog items (PBIs) based on considerations such as risk, business value, dependencies, size, and date needed.
The product backlog is what will be delivered, ordered into the sequence in which it should be delivered. It is visible to everyone but may only be changed with the consent of the product owner, who is ultimately responsible for ordering product backlog items for the development team to choose.
The product backlog contains the product owner's assessment of business value and the development team's assessment of development effort, which are often, but not always, stated in story points using the rounded Fibonacci scale. These estimates help the product owner to gauge the timeline and may influence the ordering of product backlog items; for example, if two features have the same business value, the product owner may schedule earlier delivery of the one with the lower development effort (because the return on investment is higher) or the one with higher development effort (because it is more complex or riskier, and they want to retire that risk earlier).[41]
The product backlog and the business value of each product backlog item is the responsibility of the product owner. The effort to deliver each item is estimated by the development team in story points, or time. By estimating in story points, the team reduces the dependency in individual developers; this is useful especially in dynamic teams where developers are often assigned to other projects after sprint delivery. For instance, if a user story is estimated as a 5 in effort (using Fibonacci sequence), it remains 5 regardless of how many developers are working on it
Story points define the effort in a time-box, so they do not change with time. For instance, in one hour an individual can walk, run, or climb, but the effort expended is clearly different. The gap progression between the terms in the Fibonacci sequence encourages the team to deliver carefully considered estimates. Estimates of 1, 2 or 3 imply similar efforts (1 being trivial), but if the team estimates an 8 or 13 (or higher), the impact on both delivery and budget can be significant. The value of using story points is that the team can reuse them by comparing similar work from previous sprints, but it should be recognized that estimates are relative to the team. For example, an estimate of 5 for one team could be a 2 for another having senior developers and higher skills.
Every team should have a product owner, although in many instances a product owner could work with more than one team.[24] The product owner is responsible for maximizing the value of the product. The product owner gathers input and takes feedback from, and is lobbied by, many people, but ultimately makes the call on what gets built.
Logitech support Support Home Downloads & Apps Spare Parts MyHarmony Support Ultimate Ears Support Community Forums. HD webcams with crystal clear 720p or 820p video for all your meeting and video calling needs. Webcams for Video Conferencing and Video Calling IE8/IE9/IE10 is no longer a supported browser. Free logitech webcam drivers. Creative Labs Video Blaster WebCam II Drivers (USB) Free. Get the latest Windows 98 drivers for the USB version of the Creative Labs Video Blaster WebCam II. Welcome to Logitech Support. Popular FAQs. Product FAQs. FIND YOUR PRODUCT. You can search for your product by name, model number or part number. Or, locate your product using the categories below. REGISTER YOUR PRODUCT Quick and easy help and support whenever you need it.
The product backlog:
Typically, the product owner and the scrum team work together to develop the breakdown of work; this becomes the product backlog, which evolves as new information surfaces about the product and about its customers, and so later sprints may address new work.
Management[edit]
A product backlog, in its simplest form, is merely a list of items to work on. Having well-established rules about how work is added, removed and ordered helps the whole team make better decisions about how to change the product.[42]
The product owner prioritizes product backlog items based on which are needed soonest. The team then chooses which items they can complete in the coming sprint. On the scrum board, the team moves items from the product backlog to the sprint backlog, which is the list of items they will build. Conceptually, it is ideal for the team to only select what they think they can accomplish from the top of the list, but it is not unusual to see in practice that teams are able to take lower-priority items from the list along with the top ones selected. This normally happens because there is time left within the sprint to accommodate more work. Items at the top of the backlog, the items to work on first, should be broken down into stories that are suitable for the development team to work on. The further down the backlog goes, the less refined the items should be. As Schwaber and Beedle put it 'The lower the priority, the less detail until you can barely make out the backlog item.'[2]
As the team works through the backlog, it must be assumed that change happens outside their environmentâthe team can learn about new market opportunities to take advantage of, competitor threats that arise, and feedback from customers that can change the way the product was meant to work. All of these new ideas tend to trigger the team to adapt the backlog to incorporate new knowledge. This is part of the fundamental mindset of an agile team. The world changes, the backlog is never finished.[26]
Sprint backlog[edit]
A scrum task board
The sprint backlog is the list of work the development team must address during the next sprint.[43] The list is derived by the scrum team progressively selecting product backlog items in priority order from the top of the product backlog until they feel they have enough work to fill the sprint. The development team should keep in mind its past performance assessing its capacity for the new-sprint, and use this as a guideline of how much 'effort' they can complete.
The product backlog items may be broken down into tasks by the development team.[43] Tasks on the sprint backlog are never assigned (or pushed) to team members by someone else; rather team members sign up for (or pull) tasks as needed according to the backlog priority and their own skills and capacity. This promotes self-organization of the development team and developer buy-in.
The sprint backlog is the property of the development team, and all included estimates are provided by the development team. Often an accompanying task board is used to see and change the state of the tasks of the current sprint, like to do, in progress and done.
Once a sprint backlog is committed, no additional work can be added to the sprint backlog except by the team. Once a sprint has been delivered, the product backlog is analyzed and reprioritized if necessary, and the next set of functionality is selected for the next sprint.
Increment[edit]
The increment is the potentially releasable output of the sprint that meets the sprint goal. It is formed from all the completed sprint backlog items, integrated with the work of all previous sprints. The increment must be complete, according to the scrum team's definition of done (DoD), fully functioning, and in a usable condition regardless of whether the product owner decides to actually deploy and use it.
Extensions[edit]
The following artifacts and techniques can be used to help people use Scrum.[16]
Sprint burndown chart[edit]
A sample burndown chart for a completed sprint, showing remaining effort at the end of each day.
The sprint burndown chart is a publicly displayed chart showing remaining work in the sprint backlog.[44] Updated every day, it gives a simple view of the sprint progress. It also provides quick visualizations for reference. The horizontal axis of the sprint burndown chart shows the days in a sprint, while the vertical axis shows the amount of work remaining each day (typically representing the estimate of hours of work remaining).
During sprint planning, the ideal burndown chart is plotted. Then, during the sprint, each member picks up tasks from the sprint backlog and works on them. At the end of the day, they update the remaining hours for tasks to be completed. In such a way, the actual burndown chart is updated day by day.
It should not be confused with an earned value chart.
Release burn-up chart[edit]
A sample burn-up chart for a release, showing scope completed each sprint
The release burn-up chart is a way for the team to provide visibility and track progress toward a release. Updated at the end of each sprint, it shows progress toward delivering a forecast scope. The horizontal axis of the release burn-up chart shows the sprints in a release, while the vertical axis shows the amount of work completed at the end of each sprint (typically representing cumulative story points of work completed). Progress is plotted as a line that grows up to meet a horizontal line that represents the forecast scope; often shown with a forecast, based on progress to date, that indicates how much scope might be completed by a given release date or how many sprints it will take to complete the given scope.
The release burn-up chart makes it easy to see how much work has been completed, how much work has been added or removed (if the horizontal scope line moves), and how much work is left to be done.
Definition of ready (DoR)[edit]
The start criteria to determine whether the specifications and inputs are set enough to start the work item, i.e. a user story.
Definition of done (DoD)[edit]
The exit-criteria to determine whether a product backlog item is complete. In many cases, the DoD requires that all regression tests be successful. The definition of done may vary from one scrum team to another but must be consistent within one team.[45]
Velocity[edit]
The total effort a team is capable of in a sprint. The number is derived by evaluating the work (typically in user story points) completed in the last sprint. The collection of historical velocity data is a guideline for assisting the team in understanding how much work they can likely achieve in a future sprint.
Spike[edit]
A time-boxed period used to research a concept or create a simple prototype. Spikes can either be planned to take place in between sprints or, for larger teams, a spike might be accepted as one of many sprint delivery objectives. Spikes are often introduced before the delivery of large or complex product backlog items in order to secure budget, expand knowledge, or produce a proof of concept. The duration and objective(s) of a spike is agreed between product owner and development team before the start. Unlike sprint commitments, spikes may or may not deliver tangible, shippable, valuable functionality. For example, the objective of a spike might be to successfully reach a decision on a course of action. The spike is over when the time is up, not necessarily when the objective has been delivered.[46]
Tracer bullet[edit]
Also called a drone spike, a tracer bullet is a spike with the current architecture, current technology set, current set of best practices that result in production quality code. It might just be a very narrow implementation of the functionality but is not throwaway code. It is of production quality, and the rest of the iterations can build on this code. The name has military origins as ammunition that makes the path of the bullet visible, allowing for corrections. Windows gamepad drivers. Often these implementations are a 'quick shot' through all layers of an application, such as connecting a single form's input field to the back-end, to prove the layers connect as expected.[47]
Limitations[edit]
The benefits of Scrum may be more difficult to achieve when:[48][49]
From a business perspective, Scrum has many virtues, one of which is that it is designed to yield the best business solutions. However, the efficiency by which it does so in any given organization can vary widely and is largely dependent on the ability of the organization to adhere to the implementation guidelines. Every company has its own distinct organizational structure, culture, and set of business practices, and some are more naturally amenable to this methodology than others.
Tools for implementation[edit]
Like other agile methods, effective adoption of Scrum can be supported through a wide range of tools.
Many companies use universal tools, such as spreadsheets to build and maintain artifacts such as the sprint backlog. There are also open-source and proprietary software packages for Scrumâwhich are either dedicated to product development using the Scrum framework or support multiple product development approaches including Scrum.
Other organizations implement Scrum without software tools and maintain their artifacts in hard-copy forms such as paper, whiteboards, and sticky notes.[51]
Scrum values[edit]
Scrum is a feedback-driven empirical approach which is, like all empirical process control, underpinned by the three pillars of transparency, inspection, and adaptation. All work within the Scrum framework should be visible to those responsible for the outcome: the process, the workflow, progress, etc. In order to make these things visible, scrum teams need to frequently inspect the product being developed and how well the team is working. With frequent inspection, the team can spot when their work deviates outside of acceptable limits and adapt their process or the product under development.[23]
These three pillars require trust and openness in the team, which the following five values of Scrum enable:[16]
Adaptations[edit]
The hybridization of Scrum with other software development methodologies is common as Scrum does not cover the whole product development lifecycle; therefore, organizations find the need to add in additional processes to create a more comprehensive implementation. For example, at the start of product development, organizations commonly add process guidance on the business case, requirements gathering and prioritization, initial high-level design, and budget and schedule forecasting.[52]
Various authors and communities of people who use Scrum have also suggested more detailed techniques for how to apply or adapt Scrum to particular problems or organizations. Many refer to these methodological techniques as 'patterns' - by analogy with design patterns in architecture and software.[53][54] Such patterns have extended Scrum outside of the software development domain into Manufacturing,[55] Finance and Human Resources.
Scrumban[edit]
Scrumban is a software production model based on Scrum and Kanban. Scrumban is especially suited for product maintenance with frequent and unexpected work items, such as production defects or programming errors. In such cases the time-limited sprints of the Scrum framework may be perceived to be of less benefit, although Scrum's daily events and other practices can still be applied, depending on the team and the situation at hand. Visualization of the work stages and limitations for simultaneous unfinished work and defects are familiar from the Kanban model. Using these methods, the team's workflow is directed in a way that allows for minimum completion time for each work item or programming error, and on the other hand ensures each team member is constantly employed.[56]
To illustrate each stage of work, teams working in the same space often use post-it notes or a large whiteboard.[57] In the case of decentralized teams, stage-illustration software such as Assembla, JIRA or Agilo.
The major differences between Scrum and Kanban is that in Scrum work is divided into sprints that last a fixed amount of time, whereas in Kanban the flow of work is continuous. This is visible in work stage tables, which in Scrum are emptied after each sprint, whereas in Kanban all tasks are marked on the same table. Scrum focuses on teams with multifaceted know-how, whereas Kanban makes specialized, functional teams possible.[56]
Scrum of scrums[edit]
The scrum of scrums is a technique to operate Scrum at scale, for multiple teams working on the same product, allowing them to discuss progress on their interdependencies, focusing on how to coordinate delivering software,[58] especially on areas of overlap and integration. Depending on the cadence (timing) of the scrum of scrums, the relevant daily scrum for each scrum team ends by designating one member as an ambassador to participate in the scrum of scrums with ambassadors from other teams. Depending on the context, the ambassadors may be technical contributors or each team's scrum master.[58]
Rather than simply a progress update, the scrum of scrums should focus on how teams are collectively working to resolve, mitigate, or accept any risks, impediments, dependencies, and assumptions (RIDAs) that have been identified. The scrum of scrums tracks these RIDAs via a backlog of its own, such as a risk board (sometimes known as a ROAM board after the initials of resolved, owned, accepted, and mitigated),[59] which typically leads to greater coordination and collaboration between teams.[58]
This should run similar to a daily scrum, with each ambassador answering the following four questions:[60]
As Jeff Sutherland commented,[58]
Since I originally defined the Scrum of Scrums (Ken Schwaber was at IDX working with me), I can definitively say the Scrum of Scrums is not a 'meta Scrum'. The Scrum of Scrums as I have used it is responsible for delivering the working software of all teams to the Definition of Done at the end of the sprint, or for releases during the sprint. PatientKeeper delivered to production four times per Sprint. Ancestry.com delivers to production 220 times per two-week Sprint. Hubspot delivers live software 100-300 times a day. The Scrum of Scrums Master is held accountable for making this work. So the Scrum of Scrums is an operational delivery mechanism.
Large-scale Scrum[edit]
Large-scale Scrum (LeSS) is a product development framework that extends Scrum with scaling rules and guidelines without losing the original purposes of Scrum.
There are two levels to the framework: the first LeSS level is designed for up to eight teams; the second level, known as 'LeSS Huge', introduces additional scaling elements for development with up to hundreds of developers. 'Scaling Scrum starts with understanding and being able to adopt standard real one-team Scrum. Large-scale Scrum requires examining the purpose of single-team Scrum elements and figuring out how to reach the same purpose while staying within the constraints of the standard Scrum rules.'[61]
Bas Vodde and Craig Larman evolved the LeSS framework from their experiences working with large-scale product development, especially in the telecoms and finance industries. It evolved by taking Scrum and trying many different experiments to discover what works. In 2013, the experiments were solidified into the LeSS framework rules.[62] The intention of LeSS is to 'descale' organization complexity, dissolving unnecessary complex organizational solutions, and solving them in simpler ways. Less roles, less management, less organizational structures.[63]
See also[edit]References[edit]
Further reading[edit]
External links[edit]
Retrieved from 'https://en.wikipedia.org/w/index.php?title=Scrum_(software_development)&oldid=918917666'
Comments are closed.
|