Delve into Agile methodologies, compare them with Waterfall, explore planning techniques, and discover tools like SCRUM and Kanban. Gain insights into solving common problems with Agile.

This course is designed to help learners build an understanding of Agile’s process model and its different approaches and techniques.

To understand the advantages of implementing Agile techniques, the course begins with a comparison of Agile methods and the traditional Waterfall model. Then, you’ll get to know about different planning approaches to help users effectively adjust deadlines. Next, there’s a discussion on backlogs and different visual techniques, such as burn-down charts and burn-up charts, that help increase the efficiency of projects.

You will also learn Agile methodologies including SCRUM, eXtreme Programming, DSDM, Smart and Kanban, as well as the differences and similarities between these approaches. Finally, you’ll look at some common problems and learn ways to solve them using Agile methodologies.

Learn Agile Methodologies from Scratch

# Code structure

The code consists of folders and files with classes and interfaces, but also images, configurations, and web pages. These folders and files are in a repository, or a database, where all the different versions are stored from day one. Such a repository is indispensable when multiple developers work with the same code.


Once a developer changes a number of these files, they add their changes to the repository. But, because all developers do this, other developers might have changed the same files. Now the developer has to integrate their changes with those of other developers. This takes time. As a developer spends more time on their work item, the integration will also cost more time.


# Methods of continuous integration

Here, continuous integration plays a role. This technique allows developers to integrate their code on a regular basis, at least once a day. Continuous integration means applying the following methods.

+ **Copying:** The developer begins with the creation of a copy from the repository. Developers usually do this in the morning.
+ **Writing:** The developer writes the code and tests for his new work item. The files they adapt are then checked out.
+ **Compile:** The developer runs a local build. All code is then compiled and the unit tests run.
+ **Check:** The developer is ready to check their code. So, the developer creates a new copy of all code from the repository and runs a build again. When there are problems with the integration, the code won’t compile or tests will fail. The build is broken. Now the developer adjusts their code and tests it so that it gets integrated. Then, they check it. In many projects, developers check in their code at least once at the end of the day.
+ **Automatic build:** When a developer’s code is checked in, the repository will perform a build again. All code is compiled and all tests are run again. Only if this build is successful is the integration complete.


We recommend automating the build in the repository as much as possible to avoid the manual hassle. That way, the build can be run as many times as possible, ideally every time a developer checks in code. The build should be as fast as possible. It’s wise to run these tests in the build in a copy of the customer’s production environment, if possible. This ensures that any impossibilities in this environment are signaled quickly.

Continuous integration seems cumbersome, yet this technique prevents cumbersome and expensive integrations. Continuous integration is indispensable in agile projects.


Learn the benefits of continuously integrating the codes in Agile.

Getting Started

Why does the Waterfall Process model not work?

What is Agile?

Short Iterations in Agile

Collaboration in Teams

Collaborating Roles

Agile Requirements

Estimating

Planning

Implementing Agile

Issues in Using Agile

Choosing the Most Appropriate Process Model

Conclusion

Continuous Integration

Code structure