Any analogy is at risk of being flawed, irrelevant or even ridiculous. Yet, analogies are not without their value in helping to explain software development concepts.
This is especially true of Agile Methods. It's very hard to explain to someone why Agile might be better.
For years software has been compared to everything from building buildings or bridges, to automobiles. Furthermore, debates have raged around whether software development is an engineering discipline, a science or simply art.
So what's one more analogy then?
Like cooking, I don't believe software development is an art or a science exclusively -- it's a little of both. Also, if you've ever seen the chaos that is a restaurant kitchen, you could easily agree that the team constantly deals with new requirements, changes and problems. And like food, software is very much subject to a great deal of personal preference, perception and opinion -- taste.
Let's consider the roles in a restaurant and how they compare with a software project respectively:
- General Manager -> Project Manager: Greet and seat the customers, to manage scope (how many people are seated at a time given the amount of staff and complexity of the food or requirements). Also a point of escalation when things go wrong.
- Service Staff -> Analysts: Take orders from the customers, or in other words, gather requirements. They also ensure requirements are met to the satisfaction of the customer.
- Cooks -> Developers: Implement the requirements based on the specifications (order/ticket) provided by the analyst. They taste the food to make sure it's what they expect (unit test?).
- Head Chef -> Practice Lead: Ensures that processes are followed and that high standards are met. Watches food on the way out to make sure it looks good and meets the specifications. Also keeps the team energized and motivated. In some software organizations this is an Architect or a Q/A Lead. In others it might be the Technical Lead or Senior Developer.
- General Manager greets Customer at the door, and seats them if a table is available.
- Once seated, the Server collects the Customer's order.
- The Server places the order on a ticket queue (a Story Wall!)
- The Head Chef calls out the order and prioritizes them to ensure entire tables are served at once and on time, but also identifies any opportunities to improve efficiency.
- The Cooks implement the orders as they're called out and may refer to the ticket as necessary. They taste (test) their food, to ensure that it turns out the way they intended. They report back regularly to the Head Chef with time remaining on the order.
- When the order has been prepared, the Head Chef inspects it quickly for quality.
- The Server (who is also able to make a quick sanity check that the order at least looks right) delivers the order to the Customer
- In the event that the Customer is not happy, the Server can return the order to the kitchen, at which point the Head Chef can re-prioritize and correct the order.
- In certain cases it may be required to involve the General Manager if an issue is unresolvable.
Does this sound familiar? It should if you've ever been on an Agile project. Customers are served in order of priority (arrival time in this case), there are a number of immediate check-points, and issues are resolved and reprioritized in a timely fashion. The key is that the feedback loops are short and tight.
How would a restaurant run with Waterfall?
- 5pm - 6pm: Seat all the customers.
- 6pm - 7pm: Collect all orders.
- 7pm - 8pm: Head Chef prioritizes and calls out all orders.
- 8pm - 10pm: Cooks prepare all of the orders.
- 10pm - 11pm: Head Chef checks every order, sends back all of the wrong orders.
- 11pm - 12pm: Cooks fix all of the wrong orders.
- 12pm - 1am: Analysts deliver all of the orders to the customers,
- and return all of the incorrect orders (probably cold from sitting there during the previous check/fix cycle -- stale requirements!)
- 1am - 2am: Developers err.... Cooks flail around trying to correct old orders originally received hours ago, for customers that have been waiting for hours.