Tuesday, February 22, 2011

Extreme Programming Ch 16-18 and Design of Future Things Ch 6

Extreme Programming
By: Ron Jeffries; Ann Anderson; Chet Hendrickson
Publisher: Addison-Wesley Professional
Pub. Date: October 16, 2000

Chapter 16 : Do or Do Not

lol
I'm sticking with the Star Wars themed pictures again this week:



Much like the title would suggest, this chapter lists a few do and do nots of the Extreme Programming methology.

Dos :
Well Designed Code
Well Crafted Code
Flexibly Structured Code
Properly Documented Code
Tested Code
Code that meets known and documented requirements
Design all the time
Do get comfortable taking on any story in any order
Do focus on communication
Do pay attention to your metrics and key reporting graphs
Do let everyone get involved in design
Do build cleanly for today

Donts :
Don't design the whole system before implementing
Don't try to freeze requirements before implementing
Don't produce voluminous design docs at the beginning
Don't produce docs or artifacts that aren't being used
Don't separate the team into designer and coders
Don't build for tomorrow x3 - do the simplest design first; it saves time. Improvements put in later will be easier and code stays simpler

Chapter 17 : Experience Improves Estimates

The author recommends that the extreme programmer should note how long it takes for them to accomplish a task minus the time it took to think and design.
Breaking down stories into small tasks helps with the estimation.
The author also recommends that the programmer should estimate each task that they sign up for and estimate in terms of hours, to observe the amount of time it took to implement versus the estimation, and to note why there was a difference. By noticing these things the programmer gets experience at story estimation.


Chapter 18 : Resources, Scope, Quality, Time

In this chapter, the author highlights the important metrics to keep track of during development and addresses which metrics and methods should be avoided. Key resources to track include: planned versus actual hours of work, number of developers and customers assigned to the project, number of computers and tests, etc...

For scope, the team should keep track of the stories over time and how that fluctuates over time for both achieved and yet to be achieved tasks.

For quality, the XP method endorses acceptance testing graphs with the number of tests and number succeded over time.

For time, XP recommends to track the results of each release plan to the schedule.

Overall the XP methodology urges teams to keep graphs as simple as possible and to know whether progress with respect to the number of stories is related to feature creep or whether the stories are being fulfilled at a good rate. The author notes that managers typically measure whether the project was accomplished by the release date, so her urges the reader to always deliver on time.

Finally, the chapter covers a few key graphs to use and emphasizes keeping track of the team's attitude and the surrounding atmosphere to gauge the success of the project and its tests. Usually a bad atmosphere and foul moods translate to bad code and lots of bugs.

The Design of Future Things

Design of Future Things
By: Donald Norman
Publisher: New York Basic Book
Pub. Date: November 2007

Chapter 6 : Communicating with our Machines

Expanding on previously introduced ideas of natural interaction, Norman extols the virtues of communication that is self-explaining and non-intrusive. Electronic equipment and computers tend to hide their state internally and only show the end result of their processing so that when errors occur, there is a lack of feedback that make the problems difficult to trace and largely their operation is not understood.

Norman claims that feedback is important for six reasons:
Reassurance
Progress Reports and Time Estimates
Learning
Special Circumstances
Confirmation
Governing Expectations

From there Norman makes the observation that successful products should provide an intelligible model for failure that allows the attribution of blame to fall on the user and not the machine.

Norman then introduces the idea of "calm technology" whereby communications and signaling continuously on the periphery of the users focus and only intrude when necessary allowing the user shift their focus, attend to the problem, and then allow the communication to slip back into the periphery.

Finally, Norman proposes that machine feedback should follow natural mappings for communication and already understood principles of design.
He lists six Rules:
Rule 1: Provide rich, complex, natural signals
Rule 2: Be predictable
Rule 3: Provide a rich conceptual model
Rule 4: Make the output understandable
Rule 5: Provide continual awareness, without annoyance.
Rule 6: Exploit natural mapping to make the interaction understandable

Discussion:

Extreme Programming:

A list of dos and donts is refreshingly concise and quite practical even if it does seem a bit tactless. I like the idea of not building for tomorrow in light of recent experiences. I was working on a game development project recently and I kept finding that my teammate kept expanding the scope of the project and increasing the complexity of the code unnecessarily while I was trying to keep develop as quickly and as simply as possible. We both had high expectations for the game and want to expand the game beyond the initial turnin for the class, but as it stood, the increased complexity of his codes and expectations was slowing the development and introducing bugs in the code. Most of his ideas could have been easily picked up and expanded on, but his expectations were rather inflexible which made things hard.
Anyways, keeping things simple and in the present is nice.

The chapter on experience improving estimates was stating the obvious, but its best to be thorough, I suppose.

The chapter on project metrics kept things simple, as usual, which I like to see. I agree with most of his assertions mainly because they help keep the project's progress to being driven requirements and man hours which makes more sense than the project being driven by documentation. I really like the fact that XP emphasizes working with people and noticing their frustrations or lack thereof. I'm sure that red flags are raised in people's attitudes and dispositions long before those flags are found in the code. Having things being people oriented is nice tech world where there's a tendency to focus on cold facts and the gears of systems and industry.

Design of Future Things:

Normans experiences and observations on successful products and consequences of blame and particularly insightful. Put simply, if the computer makes a mistake, it should be a reasonable mistake by the users understood model of "how it works" rather than a mistake made by the "dumb computer." If it's a reasonable mistake, then the user can compensate. Else there's just frustration.
Tech companies marketing their products to the public should take note of that.

The idea of "calm technology" is a nice treatise that addresses concern Norman had in the previous Chapter. "Calm Technology" allows for automation in intelligent technologies that allows for automation to proceed smoothly until it's needs to be attended to by the user or attendant. The user can focus on a present task meanwhile the intelligent machine simply hangs on the periphery of the users attention only to intrude without annoyance when difficulties arise rather than handling controls and operation only to intrude on a non-participating operator that isn't already focused on the operation and is thus likely to fail.

The section on natural communication design and mappings is probably a little too obvious to be written down in the book and the subject was handled much better in "The Design of Everyday Things."

No comments:

Post a Comment