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

Software that works for its user’s “user!”

Out of the blue, I get a call this morning from Eric Theoret — since it shows up as Quebec on my phone, I decide to answer. I have some very good friends and associates in Quebec… It could have been Jean-Claude or Mathieu!

On Sunday, I had placed an internet order with MacMall (I used to do all sorts of business with PCMall with 4 PCs in the house, but now i have 2 iMacs for home and a MacBook Pro as a my development/work laptop).

Eric (an Account Executive) noticed my order and saw that a 1 TeraByte HD was back-ordered. Through his energy and knowledge of various support software, Eric was able to find a HD (which the internet system was unable to locate) and add it into my order. So he called me to tell me…

Eric also mentioned how he gets into work every day before most folks, and puts in some extra time looking over the accounts and seeing what he can do to help. Well, his ability to help was very much appreciated — now i’ll get my stuff sooner.

I must say, I was very impressed:

  • with eric’s personal drive
  • that he proactively found a missing part of my order
  • and that there was good “back office” software at Mac/PCMall to allow Eric to learn about my account (he saw it stemmed from the TogetherSoft days) and really provide quality customer service.

Kudos to Eric and MacMall!

Hope he doesn’t mind, but if you need anything computer-related you can reach him from North America at 1-800-555-MALL ext 8542. Without a lot of fuss or muss, I have always found good prices and selection and quick response from Mac/PCMall… now Eric has raised the bar even further.

As a software development guy, I like to think of the software and integration and workflow that all goes into something as seemingly “simple” as what Eric was able to do.

Think about that next time you design some software… many times the benefactor is twice removed from the user!

in the weeds

so why is it that, despite warning signs going off in my head, little angels on my shoulder screaming, i let myself get into the weeds on a project?

when you are in the weeds:

  • you don’t lead
  • you don’t steer
  • you don’t allow others of the team to step up and pick up that ball
  • you only get a temporary boost
  • you can’t sustain it
  • you don’t blog
  • you don’t hang out on forums

i have bonked myself on the head!

back to sustainable pace!!

What is Design?

Some recent discussions revolved going back and forth on DESIGN.

For me… design is a multi-faceted thing… Sometimes it is a very high-level part of the overarching theme of what drives an application’s details. Generally, the design is the means by which superior business advantage is gained by our clients.

  • For an insurance agent portal application (gather data about the insurance requirements and submit…) we are building now, one of the running jokes is “Everything is a Question.” That is because my overarching design of the system is a domain model surrounding the questionnaire aspect of the system. Add to the questions meta data for the rating system (to auto-generate the XML stream for rating). The entire UI is driven dynamically by the questions set up in a questionnaire — the sample questionnaire that demonstrates all API features and rules is a Diner! Need a piece of information sent to the backend rating system? Create a hidden question and some rules to assign the answer. Need a fancier UI for some questions? Add a CUSTOM_UI meta tag and the UI will kick off a different component for that question(s).
  • For a patient clinical summary system we designed, the overarching technical aspect of this design was the “Form” — basically a set of information needed for a patient. Working backward from this request, the proper data was pulled in by autonomous agents, shoved into a “worksheet” for processing. This multi-agent system used descriptive “Semantic Web” technologies such as RDF and OWL for knowledge representation, mapping, and processing.
  • For a fire department web-based preplanning system, i used a very brute force technique to implement 50 domain objects in J2EE. Though the 2-tier menu system is table driven, the bulk of the beans are repetitive. Yes, I thought about MDA. Yes, I thought about building it in a completely meta driven manner. But, this was a homegrown, entrepreneurial project, so we used a proven and simple technique that I could deliver more rapidly.

For the first two cases above, the combination of design ideas, sketches, wiki explanations and code will give you the fastest ticket to joining the team and becoming productive.

For the 3rd example, you could jump in on examining source code for any of the 50 objects and know all there is to know about the design and start coding.

design is in the eye of the beholder also… the facets of the design that you choose to share are generally for a specific reason. Maybe for the stakeholder to understand the business value that an advanced design provides… Or, a combination of showing the application architecture + the domain models + code samples for the entire set of layers for the technical architecture is what is best for developers. To discuss the UI design, that is a whole other ballgame.

Another way I like to think about folks (like Ron Jeffries) considering the “Code IS the design:”

  • code is reality
  • design is intent

Software Engineering

do you see much software engineering in your travels?

in chatting with the Sun guys behind the new UML effort in NetBeans, i thought of the following. i have often wondered what has caused such a dearth of interest in software engineering and using modeling tools:

  • the focus on hurry up, get it done/get started coding?
  • people trained in hammering nails, but who have no clue about true engineering
  • a lack of “connecting the dots” between stakeholders/management and what is truly needed for doing software engineering, hence illusions of progress in app development projects, and the lack of transparency into the true cost of lousy-engineering
  • over hyping of tools like Rational’s — which didn’t really work as well as advertised — causing a backlash due to the disillusionment of management/development teams
  • people getting stuck in over analysis and modeling without a purpose
  • the creation of architect roles by people who could not really understand building the code and therefore were relegated by the team into non-essential folks who sit in the corner
  • tools that did not give good ROI
  • tools that tried to do too much
    • later versions of Together fell victim to this (feature lust) and i couldn’t convince peter coad to not include such features

just some random thoughts…