Trending December 2023 # What Is Agile Development? Scrum Events In Agile Methodology # Suggested January 2024 # Top 13 Popular

You are reading the article What Is Agile Development? Scrum Events In Agile Methodology updated in December 2023 on the website We hope that the information we have shared is helpful to you. If you find the content interesting and meaningful, please share it with your friends and continue to follow and support us for the latest updates. Suggested January 2024 What Is Agile Development? Scrum Events In Agile Methodology

Introduction to Agile Development

Start Your Free Software Development Course

Web development, programming languages, Software testing & others

Agile software development is Feature Driven Deployment based approach where we follow some principles:

Software developers need to satisfy the customer through continuous delivery and welcome changes even late in development.

Need to deliver working software frequently with short time intervals.

Attention to Technical expertise and good design of the functionality will improvise agility.

Need to have self-organizing teams for better architecture and requirements design.

Comparing to other models of software development like Traditional Waterfall methodology, where developer gets the requirements, develops the complete code and send it for testing of the software, here in Agile Methodology, we split the requirements on priority and co-ordinate with other teams to develop the given requirements with parallel testing the requirements done so far and release the software part by part.

This agile methodology involves Scrum framework which is used to manage complex software development employing various processes and techniques.

Scrum Master: He/ She ensures the process is followed by removing impediments and supporting development team.

Product Owner: He/ She works with stakeholders and business.

Development Team: Self-organizing team who do the requirement analysis, design, implementation and testing, etc.

Scrum Events in Agile Methodology

Scrum is simple to understand but extra effort is needed to implement the methodologies. Scrum events in Agile methodology are Sprint, Sprint planning, Daily Scrum, Print Review and Sprint Retrospective.

Sprint: It is a time-box of 1 month or less consistent duration, new sprint starts immediately after the conclusion of previous sprint. No changes are to be made once the sprint starts and scope of the project can be re-negotiated with Product owner and development team.

Sprint Planning: It is time-box of maximum 8 hours for a month sprint, it gives an overview of what are the requirements which are to be delivered in sprint.

Daily Scrum: It is a 15 min time box event for the development team to discuss and create a plan for the next 24 hours to reduce complexity.

Sprint Review: It is held at the end of each sprint to inspect Increment and adapt Product Backlog.

Sprint Retrospective: It occurs after sprint review and before sprint planning to get to know what went well in the previous sprint and what could be improved.

Artifacts in Agile

Artifacts in Agile includes Product Backlog, Increment and Sprint backlog.

Product Backlog: It is an ordered list of the product requirements which is never complete.

Increment: It is the sum of all the product backlog items completed during a sprint.

Sprint backlog: It is the set of Product backlog items selected for a particular sprint.

Scrum Framework

Given below is the diagram of Scrum Framework:

User Stories

These are the product features/ functionalities that the user wants to use in their final product which are also known as requirements. The success of a development project lies in understanding the customer requirements and implementing them in final product/ software.

In Scrum projects, product backlog consists of list of user stories and is narrated from user perspective as what he/ she wants. These user stories are prioritized and taken into sprint backlog in sprint planning meeting.

For e.g., Consider a requirement where customer wants to purchase PVR movie pass so that he gets access to purchase movie tickets at a lower cost.

Format of User story is, as a customer I want to purchase a movie pass so that I can access to purchase movie tickets at a lower cost.

This requirement should satisfy acceptance criterion defined by customer/ business.

Only one pass can be issued to one customer.

No pass to be issued if customer does not pay a one-time amount of 500 annually.

Customer has to enroll and has to have a history of watching at least 5 movies in PVR.

Maximum 3 people can be allowed on a single pass. And the criterions can go on depending upon customer requirements.

Benefits of User stories includes:

It is the customer who will be using the final product, user stories connect the end users and software development team.

The format of user story ensures to achieve the benefit that customer wants.

There is a chance to make changes to user stories during execution of the project, even though the scope of story changes, we can split it and move the user story or part of requirement to backlog for executing in further sprints.

As we deliver working software/ product at the end of sprint, scrum team can get feedback in review meetings.

Advantages of Agile Development

It promotes teamwork and cross functional training.

Functionalities can be developed and demonstrated in a shorted period.

It is a realistic approach to develop software.

Requirement of Resources is minimal.

Suitable for changing requirements.

Early delivery of working software at least partially.

Easy to manage and gives flexibility to developers.


Agile Methodologies include many software development approaches, here we have discussed SCRUM, we also have Extreme Programming (XP), Agile Modeling etc. As Agile methodology is growing software development methodology, it has made lives of software developers, testers and the organization easier as it is adaptable to change, people-oriented, speedy and responsive which are required for software development projects.

Recommended Articles

You're reading What Is Agile Development? Scrum Events In Agile Methodology

Agile Methodology Implementation In Public Sector

To develop software and manage numerous projects, government agencies are looking forward to using new ways of working. Agile methodology could prove to be the best approach. Agile focuses on iterative and incremental approaches to work on a project or developing software. Agile is a work process that has been used by the private industry for more than two decades, and now government organizations are also looking forward to using this process.

Challenges Faced by Government Organizations to Imply Agile

Using Agile in Government Projects can be challenging. Agile methodologies are completely different from the traditional project management methodologies and government organizations are quite resistant to change. To make people understand, the working system of Agile can be very stretching.

Following is the list of all the major problems faced by the government organizations in implementing and adopting Agile Methodology −

Understanding of Agile Language

Agile methodology has its own terminologies, and a language which can be quite different as well as difficult to understand. Hence, it may discourage the employees as most of them are used to traditional management methodology.

Rules and Regulations

Employees working in the government sectors have to follow many more rules compared to the employees working in the private industry. Such a working system may have few effects on their ability to change methods.

Capability and Talent gaps

Agile capabilities include product management, user-centered design, and automation engineering, which are generally absent in the government sector. The IT departments in the government sectors face difficulties while recruiting competent talent with digital knowledge. This is majorly due to the salary caps, budget constraints, and policy restrictions.

Government should create roles and positions that are necessary for the agile style of working. Hiring processes should be tailored to particular skills requirements for this way of working.

Outdated Organizational Techniques

Different organizations with cross-functional teams are required for the shift to agile.

The emphasis on end-to-end development is also necessary for it. The business organizations team that designs services or delivers products for citizens; the IT sector is often soiled away. The IT function is organized by a series of stages such as building applications, software development, and diverse projects.

Implementation of Agile Methodology in Government Sector

Here are some of the basic steps in implementing Agile methodology in the government sector −

Set a Long-Term vision

Implementation of Agile methodology in the government sector can be tricky. But if the government organizations mark long-term goals, it may help them to set and acknowledge even smaller projects. To set a long-term vision, organizations might need to create multi-year maps to navigate the project ahead.

Assurity of Understanding of Agile

Most government employees have experience working with a traditional management approach, they might not completely understand what exactly Agile is. Agile methodologies were not used previously in the government sectors; hence government organizations mostly are unfamiliar with agile practices. It has to be ensured that they understand that Agile is the future. Thereby these methods are to routinized and infused in the process of adopting.

Initiate Small Projects and Valuable Outcomes

Generally, Agile methodologies show their value with quick and small achievements. Emphasis should be given to try to figure out the part of a project that needs to be completed first. Therefore, initiate agile methods in smaller projects, thereby by focussing on delivering valuable outcomes.

Client and Customer Involvement

The involvement of client is higher in the modern Agile management in private sector, which is very rare in the government sector. Thereby, less transparency in government sector.

Problem Escalation

In case there is an issue in the project working, all the members work together to solve it in the agile management; whereas in the government sector, the issue is right away escalated to the higher management. This way time involvement to solve or find a solution is more in the government sectors.

Assumption of Clients’ Knowledge

Many times clients are not hundred percent sure of what they want from a project. In government sector, the management assumes that clients know exactly what they want and they proceed accordingly, thereby do not show flexibility in case any changes are requested by the clients. Implementation of agile brings flexibility in the changes requested by the client as per project requirement.


No project guarantees hundred percent success without any changes or issues. However, implementation of agile, especially in the public sector gives possibility of maximum benefits, less time involvement and client satisfaction.

Steps To A Successful Agile Iot Project

Want to create or implement the Internet of Things (IoT) Agile which is one of the most innovative methods. It combines the principles of agile software development with the unique challenges of building and managing connected products. It focuses on delivering value quickly, responding to feedback from users & making changes when needed. Agile IoT projects can be done swiftly & affordably in contrast to traditional IoT initiatives, which are frequently complicated, expensive, and time-consuming.

When it comes to traditional IoT projects they are often complex, costly, and time-consuming, whereas due to Agile IoT projects can be completed quickly & cost-effectively. It is perfect for companies who need to keep on top of this changing market.

Because of its adaptability and flexibility, in recent years Agile methodology’s popularity has grown significantly. It provides a more effective & efficient project management method after it works or is integrated with the Internet of Things (IoT). To guarantee success, nevertheless, some degree of preparation and coordination is needed.

In this article, we will explore more about Agile Internet of Things (IoT) project. Let’s start.

Keys Steps to Ensure Successful Agile IoT Project

Here are some key steps to a successful Agile IoT project −

The essential actions you need to follow to guarantee the success of your Agile IoT project are listed below.

Define your requirements

Before you start any project, it is essential to define your requirements. It includes identifying the project objectives, the functionality you require, and the stakeholders involved. In the case of an IoT project, you should also consider the hardware and software components necessary to achieve your objectives.

Create a product backlog

Once you have defined your requirements, the next step is to create a product backlog. It is a prioritized list of features or functionalities that you want to develop. It should be regularly updated throughout the project to reflect any changes in requirements or priorities.

Plan sprints

Agile methodology is characterized by short, iterative sprints, usually lasting between one and four weeks. During each sprint, the development team should focus on delivering a specific set of features or functionalities. It is essential to plan sprints carefully to ensure that they are realistic and achievable.

Conduct daily stand-up meetings

Daily stand-up meetings are an essential part of Agile methodology. They are brief meetings that the development team holds each day to discuss progress, identify any obstacles or issues, and plan the day. They should be short and to the point, with each team member reporting on what they have achieved since the last meeting, what they plan to do next & any issues they have encountered.

Use Agile project management tools

There are many Agile project management tools available that can help you manage your IoT project effectively. You may manage sprints, keep track of your progress, and work with the team using these tools. Some popular tools include Jira, Trello, and Asana.

Test and iterate

The agile methodology emphasizes continuous testing and iteration. It is essential to test your IoT solution regularly to identify any bugs or issues and refine your solution. Regular testing ensures that your solution meets your requirements and is fit for purpose.

Emphasize communication & collaboration

Effective communication and collaboration are key to the success of any Agile IoT project. Open lines of communication between the development team, stakeholders, and any connected third-party providers are crucial. We can have a regular meetings & updates that can allow us to ensure that everyone is on the same page also if there is any issues or concerns are addressed promptly.

Monitor progress and adapt

Agile methodology is all about adapting to change. It is essential to monitor progress regularly, assess the success of each sprint, and adjust the project plan accordingly. It allows you to respond quickly to any issues or changes in requirements and ensures that the project stays on track.

Document everything

Documentation is crucial in any project, and Agile IoT projects are no exception. It is essential to document everything, including project requirements, sprint plans, testing results & any issues or changes that arise. This document plays a major role in ensuring that everyone in the project is aware of its status of the project.


In conclusion, Agile methodology can deliver significant benefits for IoT projects. By breaking the project down into smaller sprints, you can iterate quickly and respond to changes in requirements or issues that arise. Use Agile project management tools with this you can manage the project effectively also you can collaborate with the team.

By emphasizing communication and collaboration, monitoring progress, and adapting the project plan as necessary, you can ensure that the project stays on track and meets its goals. Also, you can ensure that everyone involved in the project is aware of its status & can refer to it if necessary, by documenting everything. By following these best practices, you can deliver a successful Agile IoT project that meets your requirements & delivers value to your stakeholders.

Introduce Events In Expense Manager App

Introduce Events in Expense Manager APP

Open expense-manager application in your favorite editor.

Open chúng tôi file and add a method handleMouseEnter to handle the event fired (onMouseEnter) when the user moves the mouse pointer into the expense items (td – table cell).

handleMouseEnter(e) {"highlight"); }


Event handler tries to find the parent node (tr) of the event target (td) node using parentNode method. The parentNode method is the standard DOM method to find the immediate parent the current node.

Once the parent node is found, event handler access the list of the css class attached to the parent node and adds ‘highlight’ class using add method. classList is the standard DOM property to get list of class attached to the node and it can be used to add / remove class from a DOM node.

Next, add a method, handleMouseLeave to handle the event fired when the user moves out of the expense item.

handleMouseLeave(e) {"highlight"); }

Here, Event handler removes the highlight class from the DOM.

Next, add a method, handleMouseOver to check where the mouse is currently positioned. It is optional to find the where about of the mouse pointer in the DOM.

handleMouseOver(e) { console.log("The mouse is at (" + e.clientX + ", " + e.clientY + ")"); }

Next, bind all event handlers in the constructor of the component.

this.handleMouseEnter = this.handleMouseEnter.bind(); this.handleMouseLeave = this.handleMouseLeave.bind(); this.handleMouseOver = this.handleMouseOver.bind();

Next, attach the event handlers to the corresponding tag in the render method.

render() { ); return ( {lists} ); }

The final and complete code of the ExpenseEntryItemList is as follows −

import React from 'react'; import './ExpenseEntryItemList.css'; class ExpenseEntryItemList extends React.Component { constructor(props) { super(props); this.handleMouseEnter = this.handleMouseEnter.bind(); this.handleMouseLeave = this.handleMouseLeave.bind(); this.handleMouseOver = this.handleMouseOver.bind(); } handleMouseEnter(e) {"highlight"); } handleMouseLeave(e) {"highlight"); } handleMouseOver(e) { console.log("The mouse is at (" + e.clientX + ", " + e.clientY + ")"); } render() { ); return ( {lists} ); } } export default ExpenseEntryItemList;

Next, open the css file, chúng tôi and add a css class, highlight.

tr.highlight td { background-color: #a6a8bd; }

Next, open chúng tôi and use the ExpenseEntryItemList component.

import React from 'react'; import ReactDOM from 'react-dom'; import ExpenseEntryItemList from './components/ExpenseEntryItemList' const items = [ { id: 1, name: "Pizza", amount: 80, spendDate: "2023-10-10", category: "Food" }, { id: 2, name: "Grape Juice", amount: 30, spendDate: "2023-10-12", category: "Food" }, { id: 3, name: "Cinema", amount: 210, spendDate: "2023-10-16", category: "Entertainment" }, { id: 4, name: "Java Programming book", amount: 242, spendDate: "2023-10-15", category: "Academic" }, { id: 5, name: "Mango Juice", amount: 35, spendDate: "2023-10-16", category: "Food" }, { id: 6, name: "Dress", amount: 2000, spendDate: "2023-10-25", category: "Cloth" }, { id: 7, name: "Tour", amount: 2555, spendDate: "2023-10-29", category: "Entertainment" }, { id: 8, name: "Meals", amount: 300, spendDate: "2023-10-30", category: "Food" }, { id: 9, name: "Mobile", amount: 3500, spendDate: "2023-11-02", category: "Gadgets" }, { id: 10, name: "Exam Fees", amount: 1245, spendDate: "2023-11-04", category: "Academic" } ] ReactDOM.render( document.getElementById('root') );

Next, serve the application using npm command.

npm start

The application will respond to mouse events and highlight the currently selected row.

Item Amount Date Category Pizza 80 Sat Oct 10 2023 Food Grape Juice 30 Man Oct 12 2023 Food Cinema 210 Fri Oct 16 2023 Entertainment Java Programming book 242 Thu Oct 15 2023 Academic Mango Juice 35 Fri Oct 16 2023 Food Dress 2000 Sun Oct 25 2023 Cloth Tour 2555 Thu Oct 29 2023 Entertainment Meals 300 Fri Oct 30 2023 Food Mobile 3500 Mon Nov 02 2023 Gadgets Exam Fees 1245 Wed Nov 04 2023 Academic



What Is @Escaping In Swift

In Swift, a closure marked with @escaping means the closure can outlive the scope of the block of code it is passed into.

In a sense, @escaping tells the closure to “stay up even after the surrounding function is gone”.

But why is this useful?

Let’s say you are performing an (asynchronous) network request such that:

Function f() fetches information from a web page.

After completion, a closure function g() runs inside f().

The only way to make this possible is to pass the function g() as an escaping closure into the function f().

This tells the Swift compiler after calling f() to keep g() alive to wait for the network request to complete and the response to arrive.

In this guide, we are going to take a look at non-escaping closures and escaping closures in detail.

Also, you are going to see a demonstrative example to support understanding.

Closures in Swift

In Swift, closures are non-escaping by default.

If you pass a non-escaping closure into a function, it is called right away.

The life of the non-escaping closure ends when the function call finishes.

As a result, there will be no trace of that closure.

This is the default behavior.

Let’s see a simple example of a non-escaping closure and its behavior.

Please repeat the actions in this guide in your own code editor to truly understand what happens.

Let’s write a function add that takes:

Integers a and b

A closure called action

Right after summing the numbers up, the function add calls the action.

var sum = a + b action(sum) }

Let’s call this function with integers 10 and 20 and a closure that prints the result into the console:

add(a: 10, b: 20, { res in print(res) })



As you can see, the result of adding 10 and 20 gets printed to the console right away.

However, this default behavior of a closure can be an issue when dealing with asynchronous code.

In an asynchronous function, you might not want to execute the closure right away. Instead, you want to wait for the asynchronous task to complete before calling a function.

This is where escaping comes in handy.

@escaping: Escaping Closures in Swift

Escaping makes it possible for the closure to outlive the function surrounding it.

This means the closure can stay around to catch a network request-response that arrives later.

To make a closure escaping, use the @escaping keyword modifier in front of the closure type.

Let’s see an example of how using a non-escaping closure fails in the context of an async function, and how to fix it using an escaping closure.


Say you are using an app to message your friend and you ask them “How are you?”.

As you know, it always takes a while to get a response.

For the sake of demonstration, let’s say it takes 2 seconds for your friend to reply back.

Let’s simulate this conversation in Swift code.

To mimic this behavior, you need a function that takes a response handler closure as a parameter.

This response handler is simply responsible for taking care of handling your friend’s response that arrives 2 seconds later.

Here is how it looks in code:

print(“Hey, how are you?”)

DispatchQueue.main.asyncAfter(deadline: .now() + 2, execute: { responseHandler(“Hi, I’m doing really good.”) })

print(“Responding takes a while…”) }

howAreYou({ friendResponse in print(friendResponse) })

But this code causes a compiler error.

This is because you are trying to execute the responseHandler function 2 seconds after the howAreYou function has executed.

This is a problem because 2 seconds after calling the howAreYou, there is no trace of that function or the responseHandler closure.

Thus the responseHandler never has a chance to handle your friend’s response. It gets destroyed before the response even arrives.

The Swift compiler is clever. It knows this is about to happen. Thus it shows you an error and does not run the code.

To make it work, you should make the responseHandler closure outlive the context of the howAreYou function to see the response arrive.

To do this, you need to turn it into an escaping closure:

print(“Hey, how are you?”)

DispatchQueue.main.asyncAfter(deadline: .now() + 2, execute: { responseHandler(“Hi, I’m doing really good.”) })

print(“Responding takes a while…”) }

howAreYou({ friendResponse in print(friendResponse) })

This way you tell the program that the responseHandler is an asynchronous closure and you want it to stay alive even after howAreYou call completes.

Now the compiler error is gone and the code works as intended.

It is as simple as that!

Now your responseHandler closure is able to show your friend’s response as it can out-live the howAreYou function’s scope!

But this example is quite arbitrary.

The next logical question is when is an escaping closure actually useful.

Let’s take a look.

When Are Escaping Closures Actually Useful

Escaping closures are useful whenever you want the closure to be able to outlive the function’s scope from where you are calling it.

A great example is when dealing with network requests.

When fetching data over a server, it takes a while for a network request to complete, and thus, the response to arrive.

To perform actions on the response, you need to wait for it to arrive.

To make a closure wait for the data, it has to be able to outlive the function’s scope where it is called.

To do this, you need to use an escaping closure.

To perform actions on the response, you need to


Today you learned what is @escaping in Swift.

In short, @escaping is a keyword modifier that turns a closure into an escaping closure.

An escaping closure is useful in asynchronous tasks when the closure has to wait for the function to complete.

When you use an escaping closure, the closure outlives the function in which it is called. In other words, when the function completes, the closure stays up and keeps waiting for the response.

Thanks for reading. Happy coding!

Further Reading

50 Swift Interview Questions

What Is Exception In Python?

An exception is an event, which occurs during the execution of a program that disrupts the normal flow of the program’s instructions. In general, when a Python script encounters a situation that it cannot cope with, it raises an exception. An exception is a Python object that represents an error.

When a Python script raises an exception, it must either handle the exception immediately otherwise it terminates and quits.

Handling an exception

If you have some suspicious code that may raise an exception, you can defend your program by placing the suspicious code in a try: block. After the try: block, include an except: statement, followed by a block of code which handles the problem as elegantly as possible.


Here is simple syntaxof try….except…else blocks −

try:    You do your operations here;    ...................... except ExceptionI:    If there is ExceptionI, then execute this block. except ExceptionII:    If there is ExceptionII, then execute this block.    ...................... else:    If there is no exception then execute this block.

Here are few important points about the above-mentioned syntax −

A single try statement can have multiple except statements. This is useful when the try block contains statements that may throw different types of exceptions.

You can also provide a generic except clause, which handles any exception.

After the except clause(s), you can include an else-clause. The code in the else-block executes if the code in the try: block does not raise an exception.

The else-block is a good place for code that does not need the try: block’s protection.


This example opens a file, writes content in the, file and comes out gracefully because there is no problem at all −

 Live Demo

#!/usr/bin/python try:    fh = open("testfile", "w")    fh.write("This is my test file for exception handling!!") except IOError:    print "Error: can't find file or read data" else:    print "Written content in the file successfully"    fh.close() Output

This produces the following result −

Written content in the file successfully Example

This example tries to open a file where you do not have write permission, so it raises an exception −

 Live Demo

#!/usr/bin/python try:    fh = open("testfile", "r")    fh.write("This is my test file for exception handling!!") except IOError:    print "Error: can't find file or read data" else:    print "Written content in the file successfully" Output

This produces the following result −

Error: can't find file or read data The except Clause with No Exceptions

You can also use the except statement with no exceptions defined as follows −

try:    You do your operations here;    ...................... except:    If there is any exception, then execute this block.    ...................... else:    If there is no exception then execute this block.

This kind of a try-except statement catches all the exceptions that occur. Using this kind of try-except statement is not considered a good programming practice though, because it catches all exceptions but does not make the programmer identify the root cause of the problem that may occur.

The except Clause with Multiple Exceptions

You can also use the same except statement to handle multiple exceptions as follows −

try:    You do your operations here;    ...................... except(Exception1[, Exception2[,...ExceptionN]]]):    If there is any exception from the given exception list,    then execute this block.    ...................... else:    If there is no exception then execute this block. The try-finally Clause

You can use a finally: block along with a try: block. The finally block is a place to put any code that must execute, whether the try-block raised an exception or not. The syntax of the try-finally statement is this −

try:    You do your operations here;    ......................    Due to any exception, this may be skipped. finally:    This would always be executed.    ......................

You cannot use else clause as well along with a finally clause.


 Live Demo

#!/usr/bin/python try:    fh = open("testfile", "w")    fh.write("This is my test file for exception handling!!") finally:    print "Error: can't find file or read data" Output

If you do not have permission to open the file in writing mode, then this will produce the following result −

Error: can't find file or read data

Same example can be written more cleanly as follows −


 Live Demo

#!/usr/bin/python try:    fh = open("testfile", "w")    try:       fh.write("This is my test file for exception handling!!")    finally:       print "Going to close the file"       fh.close() except IOError:    print "Error: can't find file or read data"

When an exception is thrown in the try block, the execution immediately passes to the finally block. After all the statements in the finally block are executed, the exception is raised again and is handled in the except statements if present in the next higher layer of the try-except statement.

Update the detailed information about What Is Agile Development? Scrum Events In Agile Methodology on the website. We hope the article's content will meet your needs, and we will regularly update the information to provide you with the fastest and most accurate information. Have a great day!