“Software Development is an ideal gas: it occupies all the volume it can.” - Pat Boens
The traditional approach to software development has always been sorting out your requirements, begin designing those very same provisions, set in motion their development, carry out the standardized checks and testing, and send in the maintenance when there’s any problem.
The thing is; while each process is so neatly outlined and acting as a stepping stool to the other, there’s the tiny matter of you not being able to go back a phase. What’s done is done can be applied here. Which is when those pesky disadvantages raise their heads. Requirements all set? “But what if there are changes to be made?” Development in progress? “Sorry, but it’s taking too long!” Testing underway? “You’ve left it too late!” All this only serves to prove the point that a traditional approach to software development is not only a high risk and high-cost zone, it’s also less efficient when compared to the Agile approach.
What exactly does one mean by Agile methodology?
Agile has never just been a process. It’s both the philosophy and the method behind the construction, development, and release of products. Kinda like a set of core values that define your approach to development.
Some key aspects that define the agile approach include:
- Individuals and interactions over processes and tools; a philosophy that aims to turn that ‘group’ into a ‘team’ and establish total, unwavering commitment and collaboration.
- Functioning software over all-inclusive documentation.
- Customer collaboration over contract negotiations.
- Responding to changes over following a plan
The Agile model can be considered an example of an Incremental model; wherein software happens to be developed in incremental, swift cycles essentially prompting small, incremental releases (Each release builds upon preceding capabilities) And every single release is thoroughly tested to ensure that the software quality hasn’t been compromised. Applied to time-critical applications, an Agile approach can be summed as follows:
The team and their competence ?Priorities and client interactions ?Prototypes and frequent updates
The advantages you ask?
- Client satisfaction due to prompt delivery.
- Constant interaction between the clients, the developers and the testers.
- Software delivery takes weeks rather than months.
- Establishing face-to-face communication.
- Careful, day-to-day cooperation between the business and the developers.
- Attention to detail.
- Non-fussy adaptation to any change in circumstances.
- Last minute adjustments and requirements more than welcome.
Not everything is perfect, as they say. There are certain disadvantages to the Agile model and these include:
When it comes to delivering software; the larger ones particularly, effort assessment becomes difficult especially when it's at the beginning of the development lifecycle.
- A general lack of emphasis on the required designing and documentation.
- Easy to have a project derail if client communication appears lacking in clarity.
- Certain decisions get to be taken only by certain people. E.g. Senior programmers.
So, when does one get to apply the Agile model?
- When implementing brand new changes (Agile guarantees freedom, loss of an only a few days work and very little cost to enact change)
- When very limited project planning is required (Based on customer feedback)
- When developers and stakeholders need some reprieve from the clock (Project moves forward without fear of running into roadblocks)
Agile methodologies are a compilation of several different frameworks. The application of any such framework depends on the type of project currently underway. While there a number of methodologies that are a part of the Agile ecosystem, in this post we’re going to highlight a few of the core ones.
Scrum is considered to be the more light-weight of Agile processing tools. In a nutshell, Scrum is the combination of a small team, working shorter hours, on even smaller products with regular integration to create the bigger picture.
- Backlog - The project or the product described as a list of features.
- Results - A tabulated list of product features.
- Meetings - Day-to-day 15-minute meetings to discuss both yesterday’s operations and today’s results.
- Sprints - Short, fixed iterations typically between 2 to 4 weeks.
Scrum essentially involves the following:
Splits an organization into smaller teams; self-organized and cross-functional.
- Splits and sorts the work itself into smaller yet tactile products, based on priorities involved and the effort required.
- Even splits time into shorter, fixed-length iterations, called ‘Sprints’ (usually around 2 to 4 weeks) Sprints is essentially the breakage of a project into sizeable chunks of set tasks. Instead of a never-ending scenario; where a project just keeps being built on and on, sprints help break it up into easier, doable batches.
- Once a commitment has been made, Scrum never encourages changes within sprint.
- Optimized releases - happen after the end of every iteration.
- Priority updates based on post-release customer feedback.
- Operational even for non-software products.
Extreme Programming (XP)
As the name implies, extreme programming is focussed primarily on programming, with smaller yet non-stop releases. Extreme Programming (XP) is currently considered one of the most well known Agile development lifecycle models
Like Scrum, XP also involves the workings of a well-oiled team. Some typical XP team roles include:
Product Manager (aka the product owner; authority figure with the power to say ‘no’ if necessary)
- Domain Experts (specialists in their fields)
- Interaction Designers (responsible for UI perception)
- Project Managers (aka the ‘Scrum Master’; helps the team work)
- On-site customers
And also like Scrum, XP involves the following:
A team that works in iterations typically between 1 to 2 weeks.
- Adoption of prescribed engineering practices like pair programming, refactoring, automated testing etc
- Open to change, provided the feature hasn’t begun or if there’s a similarly sized article ready to be swapped.
- Customer influences priorities and priorities influence work.
- Again, focused more towards small-scale, continual releases.
- Immediate feedback loops
Kanban is Japanese terminology for billboard/signal board/visual board. Considered the lean approach to Agile development, Kanban focuses primarily on eliminating wastes wherever possible. Kanban’s aim lies in:
- Visualization - Splits the work into smaller pieces and uses illustrations to identify each item’s position within the workflow.
- Limiting the Work in progress (WIP) - Limits the number of items that can be in progress at once.
- Optimizing the lead time - Making average completion time as less as possible.
- Continuous delivery
Feature Driven Development (FDD)
Another lightweight agile approach to software development, FDD is both constant and cumulative. With a focus on features, the main purpose here is to deliver software that’s concrete, continuous and well-timed. When it comes to FDD, unit testing, pair programming, refactoring etc is not considered important.
Agile Unified Process (AUP)
It’s the more accessible version of RUP (Rational Unified Process) and focuses on refactoring as well as balancing any occurring changes. It comes with 4 phases that include:
Inception – Stakeholder approval, starting requirements, high-level architecture, and scope.
- Elaboration – Architectural and design detailing.
- Construction – Incremental software building.
- Transition – Release and deployment.
Dynamic Systems Development Method (DSDM)
The focus here is developing a system that’s both dynamic and ready for implementation at a moment’s notice. Which is why it carries out prototyping at every stage of the development cycle. Based off of Rapid Application Development, it has 5 main phases:
- Feasibility Study
- Business Study
- Functional/Business Model Iteration
- Design and Build Iteration
When it comes to Agile methodologies, there is none that’s supposed to be better than the other. Each framework has its own abilities and applications. It all comes down to the project taken on board. At the end of the day, Agile development is about adjusting, interacting, compromising and motivating everyone involved in the achievement of some definite goals.