Discerning agile standing still

A young developer and their team want to go the agile route… Innocently asking for some examples of complete project documentation from which to learn… spurned me to thinking if it is even possible to “see” agile without being a part of “doing” agile.

kind of an “Agile-is-in-the-eye-of-the-beholder” thing…

So, below is a scrubbed view of the wiki to date for a project. Is the project agile?


Home

* 1.0 Project Overview

   o 0.0 FAQ

   o Demand, Supply, Actuals

   o Project Roadmap

      + M7

      + M8

      + M9

* 2.0 System Requirements Overview

   o Feature Overview

      + Company and UserAs

      + Attachments

      + Forms

      + Living with SystemX

      + Payment Option

      + Questionnaire API

         # Repeated Sections

      + Questionnaire Designer Console

         # 2.5 Designing a Questionnaire

            * SystemX Default Answers

            * Questionnaire Creator

            * Questionnaire Design Rules

            * Questionnaire Issues to Resolve

            * Questionnaire Issues to Resolve (First Round)

            * Questionnaire Testing

            * Understanding Custom UI

               o Class Selector Setup

               o Current Custom UI Implementation

               o Eligibility Guidelines Setup

               o ZIPCode UI

         # SystemX Migrator

         # Questionnaire Designer

            * Building QDesigner

            * JBoss 4.2.2

         # Questionnaire Simulator

      + Roles and Privileges

      + Workflow - UserA

      + Workflow - UserD

      + Workflow Overview

      + Workflow - UserU

   o Major Feature Sets

   o Questionnaire Data Process

* 3.0 Domain Models

* 3.5 System Design

   o 3.6 System Overview

      + Sandboxes (DEV/DEV2/QA)

   o Questionnaire implementation

   o QDesigner Overview

* 4.0 Technical Architecture

   o 4.1 Performance

      + Performance Improvement

         # 'Spec. Questions' Take 2

         # Issues to Wrestle

         # On Demand Questionnaire Approaches

         # Questionnaire API Scenarios

            * ChangeInfo

            * 'Spec. Question' Processing

            * getAnswers sql

            * Save Answer

               o Process Rules

               o save answer implementation stuff

            * Save Answer-2

            * toXml

         # 'User Item' Scenarios

         # Server-Side Persistence

         # SQL rules

         # Surfacing Primary Features

         # UI Track

      + Performance Logging with custom Tag

      + Profiler Results

      + Test Harness

      + Using the Flex 3 Profiler

   o Actionscript-CF Pitfalls to Avoid

   o Architectural Layers

   o Cairngorm Info

   o ColdFusion

      + ColdFusion Language Features (Discussion)

      + ColdFusion Package Structure

      + Common CF Object types used in this project

      + Coldfusion Coding Standards & Practices

      + Quick and Dirty CFC Testing

      + Sample Sequence Diagram for CF Design pattern

      + Useful CF Info

   o Constraints

   o Design Notes

   o ColdFusion Servers

   o Portal Thin Slice

   o SQL to be used in project

      + Determining XML Tree and Node

      + Determining SystemX Codes

      + Determining PickList Values

      + Determining Proper Structure for LOB

      + 'Spec. Question' SQL Queries

      + Validation

   o Steps to "Surface" Features

   o SVN Repository - Project Structure

   o Understanding SystemX

      + Analysis of SystemX Data

      + SystemX Link Info

      + SystemX Porting Implementation

      + SystemX Validation

         # SystemX Validation Unleashed

         # Verifying UI functionality of SystemX rules

      + Territory Codes

      + Understanding 'Spec. Questions'

         # Full Sample XML from production system

         # Allowed Number of Occurrences

         # Process 'Spec. Questions'

      + ZIP Codes

   o Understanding Questions

   o Understanding Rules

      + RESET_ANSWERS property

      + Rule Data Analysis

      + Testing Rules

* 5.0 User Interface

   o UserA Dashboard

   o UserA Dashboard Popup

   o UserA Summary

   o UserA Summary Popup

   o Comments on StoryBoard

   o Dashboard Filter

   o UserD

   o UserD Task Dashboard

   o LOB Summary

   o Notes on Wireframe 2

   o Notes on Wireframe 4b

   o 'Calculated Results'

   o Question Help

   o Questionnaire 1

   o Questionnaire 2

   o Questionnaire Presentation

   o Questionnaire UI Concepts

   o Select LOB

   o Summary Popup

   o UserU Dashboard

   o UserU Referred Details

* 6.0 Flex UI Implementation

   o UserA Workbook Dashboard

   o Flex UI - UserU Dashboard

   o Flex UI - UserU Editor

   o Questionnaire Functionality

      + UI - QEditor - ClassSelector

         # Class of Business and SystemX

      + UI - QEditor - CreateNew Custom UI

      + UI - QEditor - ListerView

   o UI - UserA 'User Item' Workbook Dashboard

      + UI - UserA Workbook Dashboard - Callout

      + UI - UserA Workbook Dashboard - ColumnFilter

      + UI - UserA Workbook Dashboard - Createnew

      + UI - UserA Workbook Dashboard - DashboardGrid

      + UI - UserA Workbook Dashboard - DashboardGridHeader

      + UI - UserA Workbook Dashboard - Reassign

      + UI - UserA Workbook Dashboard - Search

      + UI - UserA Workbook Dashboard - Summary

   o UI - Applicatiion Buttons

   o UI - Attach Files

   o UI - UserD Dashboard

   o UI - Eligibility Viewer

   o UI - Image Assets

   o UI - Message Viewer

   o UI - 'Calculated Results' Breakdown

   o UI - QEditor View - Multiple Questions

   o UI - QEditor View - Single Question

   o UI - QLister

   o UI Question Help and Ability to ask a Question to UserU

   o UI - Questionnaire

   o UI - 'User Item' Workbench

   o UI - UserU Dashboard

* Brainstorming

* Build Info

   o Build Button

* Coding Templates

   o Email Message Template

   o Error Handling

   o Error Handling & Logging

   o How To Code for Privilege Checking

   o Logging Functions Explained

   o Using Images in the Flex UI

* Documenting Your Code

* Feature List

* Getting to Production

* Infrastructure

   o Build Process

      + ALPHA Build

      + Coordinating SystemX DB changes with the Sales Portal

   o Communications Tools

      + IRC

   o Development Environment

      + Database Setup

      + Install for Mac

      + Step1 - Installing Subversion and TortoiseSVN

      + Step2 - Local Server Setup

         # Migrating from CF7 to CF8

      + Step3 - Flexbuilder Installation and Configuration

      + Step4 - Create Eclipse Projects

         # Configure SVN Ignores

      + Step5 - Using Shared Snippets in FlexBuilder

      + Step6 - Flash Player Debugger

      + Step7 -- Miscellaneous Tools

   o Jira Issue Tracker

   o Phase I - Maintenance

   o Phone Usage - Bridge line vs Conference Call

   o Self-Service Tools

   o Technologies

   o Unit Testing

      + CFUnit Tests

      + MXUnit Testing

      + SQL Unit Tests

   o VPN

   o Wiki

* Meeting Notes

* Dev Google Calendar

* Miscellaneous

* People

* Perspective

* Preserving Forms QR Data

* Process

   o 7.0 Testing Process

      + Application Demos

      + Common Errors

      + Original 'User Item' from XML Tool

         # Troubleshoot Final Calculation Issues

      + Performance Track Testing

         # Creating Mock Objects

         # Setting Up And Using MXUnit

      + SystemX XML Generator Tool

      + 'Business Item' Regression Test Tool

      + 'Business Item' Testing Async Issue

      + Quality Assurance Testing

         # finding why a 'User Item' does not match the expected value

         # 'User Item' from 'Business Item' XML Tool

            * 'Business Item' To 'User Item' Notes

   o Agile Process

   o Communications

   o Daily Scrum

   o Decision Making

   o Development

      + Branch Development

      + Flex Coding Standards

      + Parallel Development

   o Iterations

   o SystemX and Migrator Process

      + Analyzing deltas in migrator and real tables

      + Migrator Rule Data

   o Quality Assurance

   o Release Planning

   o Standalone Database Ideas

   o Using Jira Issue Tracker

   o Using the Wiki

* Standards

   o Flexisms

   o Whitesmiths Coding Style

* z Getting Started

I would advise against that

Many times, we in the technical community are faced with well-meaning users and stakeholders that ask for something “their way.”

My wife and I stopped in a fine Italian restaurant for lunch. Sue ordered a risotto dish, while I ordered a grilled salmon over mixed baby greens. When the risotto was served, the waiter offered to sprinkle fresh grated cheese. I was ready to get a fresh spoonful of that cheese deposited right in my mouth, it looked so good.

Then the waiter turned to me and my “salad” and offered pepper. I blurted out that I would like some cheese. (Sue cringed, as she always tries to remind me that Italian fish dishes should never be served with cheese with seafood. )

Back to the technical point… the waiter was very diplomatic:

“I would advise against that.” he said. “Oh! That’s right, no cheese on seafood! What was I thinking?” “Well, rules are meant to be broken, so you may do that if you like. I would just advise against that.”

He didn’t say I was wrong. He didn’t say I couldn’t have what I had asked for. But he carried a certain authority of being “in the know” and I trusted his judgment.

I hope to use this gentle technique the next time I need to respond to a user’s well-meaning, but “wrong” request. Maybe it will help you out as well.

Talk is Cheap

In the agile usability forum, Steve Gordon astutely observed:

“Making these choices is a business decision that requires balancing strategic and tactical considerations in the specific context.”

i agree. imho, one of the roles we, as software professionals play, is to provide the business with some “cost” information and some potential alternatives. when a specific feature idea comes forth from the business side, we are to provide cost (in terms of effort, schedule, and even downstream ramifications). We can also discuss various variations on a theme. For example, many times the development team might say: “Well, providing X is expensive and would take 6 months. However, we could do Y — which seems like it would achieve nearly the same result — for a much smaller cost, and have it done in one month.”

Talk is (usually) cheap(er) than one-way (non)conversations.

That is, a non-agile “Company A” might simply spit out a new feature set idea in an email. Then, the dogmatic development team spits back a single answer (it will cost X). Business chooses not to go forward. Meanwhile, competitor B implements Y and drives Company A to lose business and go bankrupt.

Or, non-agile Company A accepts excessive cost X. Company B does Y, gets it done sooner and eclipses Company A’s much later release of an only slightly better feature X. Company B makes more money, Company A never recoups the cost of feature X.

Talk is cheap — and that’s a good thing when it comes to working as a team for a common goal. Company A did not have a discussion, and it cost them dearly.