Wednesday, March 30, 2011

Mythical Man Month Ch 10-12

Mythical Man-Month, The: Essays on Software Engineering, Anniversary Edition
By: Frederick P. Brooks Jr.
Publisher: Addison-Wesley Professional
Pub. Date: August 02, 1995

Chapter 10 : The Documentary Hypothesis
Brooks claims that there's a small set of critical documents that
manager are necessary while other considerations may be mere distractions.
The critical "documents" (or critical points to cover in documentation) are:
Objectives
Specifications
Schedule
Budget
Organization Chart
Space Allocations
Estimate, Forecast, Prices

Brooks expounds on the last point by saying that these three variables feed
into each other and create a negative or positive "spiral." The flow of the spiral depends on whether the prices are below or above the budget estimates. Brooks notes that the negative spiral requires a discipline among all members of the team to trim down the project and get the most performance in order to ultimately succeed.

Brooks also takes a look at the necessary documentation in an university department and finds that they correspond to the average computer project in that the main components include objectives, product specifications, time allocations, money allocations, space allocations, and people allocations; or in other words, the "what, when how much, where, and who." These same considerations also carry over into software projects.

Brooks cites that the act of writing formal documentations reveal the holes in system design and solidify requirements for the project. Secondly, the documentation helps fulfill the roles of communication required of the manager and "lighten his load." Finally the documentation sets down a check list to monitor progress.

The task of a manager, claims Brooks, is to develop a plan and realize it.

Chapter 11 : Plan to Throw One Away

Brooks, realizing that the first implementation of a complex system is bound to have bugs and not adequately compensate for the difficulties inherent in such complex systems or be able to scale up for large scale use. Brooks purports that the first implementation of a system should be thrown away and that throwing the first away is inevitable, so the team/manager should plan to do so anyway.

Changing requirements of the client and changing technology is a fact of life, so management should embrace change and be flexible, but only within a limit, otherwise, the project would never reach an end. Management is to embrace the fact of continuous change by planning to throw one away, documenting changes to reduce errors, and careful tracking of the schedule and speed of implementation.

Brooks also notes that the entire company organization should be flexible to allow for change and to allow for technical and managerial people to both perform high level work and get their hands dirty in lower level implementation work so that their skills are shared and talents can come to forbearance. To do this, managers need technical refreshers, technical people need management training and problems on either domain should be communicated to the other.

From there Brooks has a word on system maintenance and notes that bug elimination usually proceeds as a "two steps forward, one step back" process since local bug fixes tend to introduce bugs at the system level. As system maintenance proceed, a kind of system entropy is introduced where bug fixes follow a pattern of "one step forward and one step back"

Chapter 12 : Sharp Tools



Brooks cites that one of the main problems on programming projects is communication, and as such, "individualized tools hamper rather than aid communication." Furthermore, technology changes across machines so tools don't last long. However, there is still a need for specialized tools for specific tasks. The problem is complex enough that Brooks proposes that a specific tool specialist should be employed to manage and update tools for the entire team. Brooks also claims that a separate computer facility be available and standardized languages, OS, utilities, debugging aids, test case generators and text processing system be used.

Access to a common computing resource by multiple small teams should be done by giving them a longer dedicated session that lends to productivity rather than splitting the resource and maximizing access by using smaller sessions. Brooks also advocates usage of graveyard shifts to maximize productivity. Brooks continues to cover simulators, compiler and assembler "vehicles" (machines), program libraries, program tools, documentation systems, and performance simulators.
Key points included providing programmer copies that are separated from formal releases using high level tools, word processing, and simulators to enhance productivity, communication, and reliability, respectively.

Discussion :

Despite the overall adherence to heavy formal documentation in previous chapters, Brooks switches gears and claims that documentation, while it needs to be thorough, can be vastly simplified into a small set of categories that answer the basic questions that anyone would have for a system. From personal experience, I find this to be true. Setting out the what, when, where, how much, et cetera really does communicate to both the team and overseers and gives a clearer view of the project ahead that allows things to proceed more smoothly both from the managers perspective and overall-progress-made perspective.

I've heard the famous phrase "always plan to throw one away, you will anyway" from multiple professors and other sources, and I never realized where the idea originated from. Once again, personal experience bears witness to the truth of the phrase despite my natural repulsion from the idea. I will say that I think that the first implementation to be thrown away should be done rather quickly as is promoted in agile development methodologies so that not too much time or effort is wasted and so that the team members don't grow too attached to the code that is going to be thrown away. The idea is to learn how to approach the problem and discover problems early and I think that should have been emphasized.

Finally, the chapter on "Sharp Tools" fell a little flat to me. Perhaps its the age of the text. I think there's been enough improvement in some of the lower level computer systems and enough progress on standardization that a lot of his concerns about tools and consistency invalidates the need for a dedicated tools specialist. Usually the software that's going to be used on a project is discovered early on and in such a way that the target system is developed adequately for and usually the software is easily ported to other systems.

Wednesday, March 23, 2011

Mythical Man Month Ch 7-9

Mythical Man-Month, The: Essays on Software Engineering, Anniversary Edition
By: Frederick P. Brooks Jr.
Publisher: Addison-Wesley Professional
Pub. Date: August 02, 1995

Chapter 7 : Why Did the Tower of Babel Fail?



Lack of communication. Even though the people who were building the Tower
of Babel had all the time and resources they needed, they failed because of
a lack of communication that led to a lack of organization. Without communication
a large system can't be put together.

Communication can occur:
informally,
in meetings,
or formally through a documentation structure called a "Project Workbook"

Brooks describes the project workbook as a kind of physical data structure
that includes:
Objectives
External Specifications
Interface Specifications
Technical Standards
Internal Specifications
Administrative Memos

Brooks claims that by applying a structure at the beginning of the project, much of the structure and organization in the design of the documentation will carry through to all later documentation since, "Technical prose is almost immortal."
The project workbook also controls how information is conveyed to the whole team.

Brooks recommends numbering an ordering all memos and setting up a hierarchical tree structure for all the documentation.
He then recommends that the documentation should be updated very frequently and to highlight all changes with a dedicated edit margin at the side of all documents. He then recommends the distribution of change logs. By doing these things Brooks claims that the documentation should scale up effectively.

Brooks admits that this can cost a lot of time, energy, and material so he mentions something called a "microfiche," but doesn't really explain what it is.

Brooks then addresses how to set up the project workbook electronically and recommends a similar highlighting of revision updates an storing files in a LIFO structure.

Brooks then talks about organizing for large projects and brings up the problem of how communication takes place in those structures. He proposes that division of labor and specialization of functions in a tree like authority structure are good tools for tackling this problem.

An organizational subtree should have:
1) A mission
2) A producer
3) A Technical Director or Architect
4) A Schedule
5) A Division of Labor
6) Interface Definitions Among the Parts

He then dives into the structures that can be found in the technical director (that conceives design, identifies subparts, and provides conceptual integrity) and the producer (that assembles the team, divides the work, and establishes the schedule).

Combinations are:
Producer = tech director
Brooks claims this is rare in occurrence and rarely workable.

Producer > tech director
It's hard to establish the director's authority to make technical decisions in ways that don't detract from his time.

Tech Director > Producer
Brooks provides a section of Robert Heinlein's Book: "The Man Who Sold the Moon"
Brooks thinks this is best for small teams.

Chapter 8 : Calling the Shot

In this chapter, Brooks talks about estimations of productivity and discuses why they always fall short.
He first observes that linear extrapolation of estimates are inaccurate and that the number of man-hours needed for increased number of instructions increases exponentially at a 1:1.5 rate.

The reason for the mis-estimations in Portman's data is that they didn't account for things outside of strictly programming and design like machine downtime, meetings, and paperwork.


Aron's Data from IBM support Portman's data.

Harr's Data from AT&T Bell labs indicate that difficulty of the implementation factors into time either in the form of the number of modules, complexity of the implementation of the number of men assigned to it.

The OS/360 data confirms Harr's data showing that compilers are generally more difficult than batch applications, and that OS's are even harder than those.

Corbato's data shows that high level programming languages can increase the productivity on a project by up to 5 times and that the number of errors are constant to the number of statements.

Chapter 9 : Ten Pounds in a Five-Pound Sack

Brooks enters into this chapter to discuss how to get the most value out of program for the space that it occupies in memory.

Brooks says that size itself is not bad, but unnecessary space usage should be avoided.

Brooks recommends that total size targets as well as resident-space budgets and that the designer should specify what a module must do when considering size for all parts of the system. Speed considerations have to be taken along with the amount of space available for certain resources. Having a fast memory access disk does not imply that all the sections of the program can abuse the space. (Similar to the tragedy of the Commons)

When considering space, granularity of tools and functions that can be added should also be considered so that many individual tools are not added unnecessarily and that each part should come together to a meaningful whole.

Space-time tradeoff should also be considered and Brooks observes that with more space, generally, more speed is gained.

To be aware of the kind of tradeoff considerations that exist, programmers should be trained for the particular technology they're working with and that good programming techniques are observed.

Finally, Brooks proposes that the Essence of Programming is representation and that most gains in technology and advances in the field are done be reconsidering the representation of the data rather than getting bogged down in the specifics of the code.

Discussion :

While this set of chapter was slightly drier than his previous ones, his basic observation on organization and communication are well founded. Again, his writing shows signs of its age when he talks about things like feet deep stacks of paper based documentation but one also has to consider the unending stacks of documentation that can be generated electronically and how we can best organize, communicate, and update large teams despite huge amounts of data. His ideas on highlighting changes and having the documents constantly available are quite sounds.

I can't say I got too much from his discussion of the technical director and the producer and it's probably because I haven't been exposed to the business organization side of software development but the idea of leading the technical man lead rings true to me.

His comparison of data on productivity is nothing new, we all know that time to implement drastically increases with number of people and complexity of implementation. I'm definitely glad we're not programming in Machine Code very much anymore.

His discussion on space time considerations are almost completely outdated. Memory is both cheap and widely available so working so hard to put value into small amounts of space isn't all that important. His last observation on chapter nine about programming being about representation was noteworthy. Often times, I feel like programmers are in too much of a hurry getting something of work to really think about design and representation that will best achieve the goal implementation to the point that we tend to implement bad solutions that could be so much more.

Thursday, March 10, 2011

Extreme Programming Ch 22-24 and Inmates Are Running the Asylum Ch. 3 - 5 and Mythical Man Month Ch 4 - 6

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

Chapter 22 : Handling Defects

In the extreme programming model, the word "bugs" is taboo because it implies that bugs are out of the programmer's control. Instead words like "defects" are promoted to enhance the responsibility and feeling of control over them.

When defects are found, they are to be scheduled with the story card system that allows them to be assigned to a programming pair team along with an estimate of the amount of time to implement it.

If the defect fix has a high priority, then other stories will need to be delayed. In that case, XP advocates keeping track of the amount of time fixing defects and reporting these figures to the customer and explaining how it will affect the release time which should already include a defect fixing time factored into the original estimate.

A dedicated defect fixing team is fine, but it helps to have the "string" feedback of bugs hurt the team to spur them into making higher quality code the first time and prevent creating the same mistakes again.

The presence of a defect indicates that a unit test missed it, so XP says to go and fix the test so that it actually catches the defect.

As a general outline, defects are handled this way:
Report
Schedule
Test to Fix
Prevent

In the advanced topics section, bug tracking database tools are played down simply because XP methodology provides the feedback, communication, and testing that should allows teams to uncover bugs efficiently.
This advanced section also mentions a few ways to keep track of defect tests.

Chapter 23 : Conclusion

This 'final' chapter closes the main content by citing that the XP methodology has worked well for the authors and that they'd never go back to developing software like the way they did before XP.

They cite the main virtues of XP as being courage, simplicity, feedback, and communication. They said that many of the pitfalls of other programming methodologies is their fear of failure and the unknown and that XP works to counteract those with communication and empowerment.

XP cites 12 key practices:
1) On Site Customer
2) Small Releases
3) Planning
Story Estimation
Customer Defines Release
Iteration Planning
Steering
4) Metaphor
5) Simple Design
6) Pair Programming
7) Collective Code Ownership
8) Continuous Integration
9) Coding Standard
10) Testing
Acceptance Tests
Unit Tests
11) Refactoring
12) Forty-hour Week

Chapter 24 : We'll Try

The saddest expression used by a programmer. It sums up the dilemma of the programmer/team forced by management into developing software that they know they can't deliver on time. XP proposes that the best option is to outline the program into stories with estimates on the number of perfect engineering days it would take to accomplish, multiply that number by 3 as the actual time to implement, and to lay all these cards in front of the managers/customer and be frank about what it will take to accomplish these cards. As the product is delivered, management will see that the estimates are usually close to right and begin to accept these estimates and schedule around those and not the other way around.

All the stories will never be caught at once and estimates will be rough at first but these practices should overcome the toughest and most stentorian of managers.

Inmates Are Running the Asylum,
The: Why High-Tech Products Drive Us Crazy
and How to Restore the Sanity
By: Alan Cooper
Publisher: Sams
Pub. Date: February 24, 2004

Part 2 - It Costs You Big Time

Chapter 3 : Wasting Money

In this chapter, Cooper claims that money is wasted by not understanding what
the software to be developed actually does for the user and what it means to be "done" developing a certain product. Naive ideas for a software product's requirements usually include things like "runs on target computer," "doesn't crash," and "fulfills X features."

Lack of adequate specification or description of the goals of the users of the program leads to expansion of the project's scope and confusion about when a deadline should be set. Furthermore, descriptions of a product based on features leads description of the product desired, much like a describing a cake's ingredients doesn't lead to a description of an actual cake.

Since the deadline could expand infinitely based feature creep from the programmers, managers tend to arbitrarily set deadlines and usually, in response to Parkinson's law, at a point much too early to be able to realistically deliver by.

Other factors that lead to unrealistic scheduling include fears that the product will never actually ship leading to the delusion that it is better to ship an undesirable project on time than a desirable project late. Cooper makes the point that a well designed product will capture the market over products that have been rushed out because they are a pleasure to use.

Elicitation of feature lists that can't be accomplished on time leads team members on the programming side to bargain and haggle with managers about what features can possibly be delivered rather than really examining which features are important and desirable to the end product.

To fuel the mad dash toward delivering features and products quickly is the propagation of the myth that the technology market is unpredictable. Hence, "design" should be done in iteration where users complain until they get something that is bearable rather than doing good design upfront.

Badly designed software also incurs high hidden costs of destroying customer loyalty by, time to develop, reputation, and buggy software. Bad software that is used in business contexts can cause workers to be unhappy and to lower their productivity. Bad software also requires tech support which can cut into the bottom line.

Bad software (or any software) is also difficult to replace, so software should be built correctly the first time. Prototypes lure managers into using bad code as foundational code because it deceives them into thinking that the code works well when it doesn't actually scale into robust commercial use, therefore, Cooper discourages and warns of their use.

Lost opportunity costs (programmers not working) also forces management to rush into the coding phase of development rather than doing design.

Chapter 4 : The Dancing Bear

In this chapter, Cooper describes bad software.
Cooper claims that people are trapped by bad software and usually don't realize it or simply assume that it's the best that technology can do at the current point.
Bad software is usually covered up by simply labeling the product as "user friendly."

Cooper then explains a few drawbacks of e-mail, scheduling programs, calendar software, and local executable software (as compared to browser based) could benefit from good design.
(Depth of the inbox, identification of resources that should be managed, how people really interact with time and their classification, and getting rid of the installation process, respectively)

Cooper highlights several things about software that is 'bad':

Software forgets input and interaction history.

Software is lazy and makes the user work harder than they have to or works in a way that the programmer would like as an expert.

Software is parsimonious with information and doesn't display all the information that a human would usually need.

Software in inflexible and the user can only act with the information in ways that reflect how the computer it is used to dealing with information. Ex: Stacks only display the top item and not the depth while humans want to shift things on the stack as they need/want them.

Software blames users for errors and gives rude and uninformative error messages.

Software won't take responsibility and defers to the user to make sure that the user chose the right option which makes the user feel stupid.

Chapter 5 : Customer Disloyalty

In this chapter, Cooper stresses desirability as the component that unites a companies managers and programmers and makes the business successful. Managers tend to deliver viability (sales numbers) while programmers deliver capability (features) bu these need to be balanced by desirability that commands the customer's loyalty.
Commanding loyalty insulates the company from market fluctuations and poor delivery of capability or viability. With desirability users are able to become advocates of the software and free them from being an apologist or a survivor.

Cooper illustrates this concept by comparing three companies:

Novell: First to market, low desirability and minimal capability and viability
=> No loyalty, fast decline with competition
Microsoft: High viability, medium capability, low desirability
=> Begrudged market leader with amazing leader = Bill Gates
Apple: High desirability, medium capability, low viability
=> fiercely loyal, slow decline

Lastly, Cooper downplays time to market considerations, emphasizing that quality will command the market in the long term.


Mythical Man-Month, The: Essays on Software Engineering, Anniversary Edition
By: Frederick P. Brooks Jr.
Publisher: Addison-Wesley Professional
Pub. Date: August 02, 1995

Chapter 4 : Aristocracy, Democracy, and System Design

In this chapter, Brooks contends that "conceptual integrity is the most important consideration in system design," that reflects a unified and directed set of design ideas rather than to have a good set of features that are uncoordinated.

To this end, Brooks illuminates how to achieve conceptual integrity and how the concept ties into philosophical and practical considerations of achieving it.

First, Brooks asserts that the purpose of programming system is to make it easy to use and that the only way to truly achieve this, simplicity must be balanced with range and power of various functions. Ease of use is promoted by having more consideration given to functional specification that to the time taken in learning and searching how to use those functions.

In other words, good design and clear goal specification for the user must be directed by a set of architects that promotes simplicity and straightforwardness thereby leading to ease of use.

Next Brooks covers the philosophical considerations as it relates to Aristocracy, the rules of a privileged few, and Democracy, the rule of many. Brooks advocates Aristocracy in that he wants design to be delegated to a few dedicated architects for unity of design but also admits that much of the creative works and good input for design can and does come from the many.

Brooks addresses fears of lost opportunity costs and productivity by making the implementers of the system wait on design by saying that many of the tasks can in development can be done concurrently in three separate phases of development:
Architecture, Implementation, and Realization.

Chapter 5 : The Second-System Effect

In this chapter, Brooks discusses the "Second-System Effect" in which the second system to be designed usually has excessive feature and "frills" that were left out in the first design. Usually these features are not inline with changes of design and intended functionality and hence, discretion and discipline should be used and encouraged.

In order for an architect to be successful in this, he must consider the limitation of scheduling and estimation of the project length. To keep this consideration in mind, the architect(s) must communicate with the builder(s) and be careful to:
suggest and not dictate ways of implementation to promote inventiveness and creativity
deal quietly and privately in suggestions
be ready to forego credit for suggested improvements

Chapter 6 : Passing the Word

This chapter expounds on the subject of communication and how an architect maintains conceptual integrity on large teams.

There are several venues:
The Manual - Communicates with users
Formal Definitions - specificity in formal definitions vs. clarity of natural language
Direct Incorporation (of definitions and concepts) - adherence to design
Conferences and Courts - Team involvement/input, unity, communication, and feature control
Multiple Implementations - Enforces system adherence to design rather than the reverse
The Telephone Log - informal and quick
Product Test - acts as the customer and forces quality


Discussion:

Extreme Programming:

The shift in perspective in owning up to "defects" rather than submitting to the mercies and whims of "bugs" is a powerful, I think.

XP's methods of dealing with defects, however, I think highlights the drawbacks of XP since it's easy to introduce a lot of defects with bad programming on the iterations and not properly take into account enough time to handle all the defects. Overall, I think this could lead to significant deadline delay.
But maybe I'm just a pessimist.

Looking back at the main points of the summary, XP is a methodology I would recommend just for its simplicity and its attempts at changing the viewpoints toward efficacy and improvement of software.

The first bonus chapter that talked about "We'll Try" rang a bell to me from my first internship. I remember my boss coming in and asking what I could show and it wasn't everything and I felt a little ashamed I couldn't deliver more. Having a bit of control and outlining the system in cards would have helped explain my situation.

The Inmates are Running the Asylum:

Coopers observations are blunt but they ring true. Badly designed software costs not only money, but more importantly, loyalty and grinds away at our lives in frustrating ways. Thinking about software in terms of goals rather than requirements and features seems like the healthiest focus for a business and would certainly illuminate the implementation of a project more clearly.

Coding well the first time is a point well worth making because I know I find code hard to throw away from personal experience but motivating businesses to do good design in the light of opportunity costs is probably a problem that needs a more specific plan despite the obvious advantages of doing design.

Despite being an older book, many of Coopers illustrations of bad software are still readily observable in related example, if not directly. File systems don't always remember where I last saved a similar document and it's frustrating directing the file directory to the correct place again.

Cooper frustrations with the move to browsers is kind of funny in retrospect, but I wonder what the world could look like if we had focused on doing better design on local programs.

Mythical Man-Month:

Once again, Brooks shows his innate urbanitas and intelligence in his writing style and diction and I must say that I am impressed. His work has aged fairly well despite the advances of technology and his comparisons to cathedral architecture are timeless although they may require some foreknowledge. It's ironic that many of his examples and allusions to other arts hold up better than many of the actual computer systems and software he talks about.



Brooks' ties into the philosophical considerations show great insight and consideration for the positions of peoples in the various roles of a development team. It would have been easy to offend in asserting that an aristocratic is the preferred model for system design but he makes strong arguments in favor of it while simultaneously making delicate concessions and considerations to the "cogs in the wheel" by pointing out the implementation is a "creative process of the first order."

Brooks examples on up-keeping communication show their age also. He includes consideration of "phone communication" that technically still exists today but would probably be trumped by considerations for instant messaging or email. But his points still stand, despite their age.

Tuesday, March 1, 2011

Extreme Programming Ch 19-21 and Design of Future Things Ch 7 and Inmates Are Running the Asylum Ch. 1 - 2 and Mythical Man Month Ch 1-3

NOTE:
So I accidentally read the last chapter of The Design of Future Things and blogged about it. I felt like I did good work so I'm leaving it in here.

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

Chapter 19 : Steering

Since XP's goal is to put out high value software in time, steering is needed to ensure that it does. To this end, XP recommends keeping track of stories, making accurate estimates, and to proceed at the pace your measuring while making sure that essential customer features are not cut.

Chapter 20 : Steering the Iteration

XP emphasizes that the main point of each iteration is to finish stories.
Therfore, it offers recommendations on how to do that:

The first recommendation is to get some stories done completely rather than to get all stories mostly done.

The second recommendation is to continuously improve estimates based on midproject feedback, project resources, and reflection.

The third recommendation is to track story progress regularly at meetings or with a dedicated tracker personnel, preferably someone who is not judgmental and can motivate others to perform better without hard feelings coming out as a result.
Rotating the tracker or using the customer as a tracker is discouraged.

Tracking helps the project stay on track, obviously.

Chapter 21 : Steering the Release

Two things are needed important at the release level:
1) When to release
2) What is released

Controlling the scope of the project is necessary in order to deliver on time which is a large measure of success at the managerial level.

XP emphasizes prioritizing essential story cards with the most points and completing those first, keeping track of the time to complete specific tasks with accurate estimates and using those measurements to project the amount of points that can be accomplished before the release. This prioritization allows the scope to be controlled and stories can be deferred at the end, if need be.

The Design of Future Things

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

Chapter 7 : The Future of Everyday Things

In this chapter, Norman closes his book with a set of projections about what the future will actually be like with regards to "smart technology."
Norman begins by discussing the "magic mirror" of tomorrow that will communicate with other devices, be used to shop for clothes and display your image in them, and even change your physical appearance on the mirror. He discusses this to make the point that what seemed like magic yesterday may become our future.

Norman highlights how quickly things have changed by bringing up his first book, "The Design of Everyday Things" where he discussed design problems with doors and stove tops. Now though we confront intelligent appliances, vacuuming robots, and recommendation systems.

Norman also talks about 3D printers that synthesize objects out of thin-air.
He mentions the materials revolution taking place in nanotechnology, biotechnology, and and corresponding advances that blur the line between man and machine.



Norman also makes recommendations about how robots should be used in the near future. Mainly he claims that robots should be specialized for their domain and communication with users minimized so that failure in communication is minimized and expectations are known on the side of the human actor. He claims that robots could best be used for education, entertainment, and dangerous jobs and that general purpose robots are far off from being implementable.

Furthermore, Norman observes that while biological change is naturally conservative, the mind itself is malleable. Hence, mankind will tend to bend to the flow and ebb of technology rather than technology bend to the whims of men.

Finally, Norman claims that design should incorporate aspects of science and art and that education and application of design should be general in nature rather than applied by focused specialists.

Inmates Are Running the Asylum,
The: Why High-Tech Products Drive Us Crazy
and How to Restore the Sanity
By: Alan Cooper
Publisher: Sams
Pub. Date: February 24, 2004

Part 1 - Computer Obliteracy

Chapter 1 : Riddles for the Information Age

Cooper starts his book by introducing a few cases displaying the frustration of working with computer and their inherent difficulties in computer human interaction.
Each of these cases show how digitization and the expansion of computers into various objects and devices has transformed their behavior.
Cooper starts with the case of an airplane crash that resulted from an inexpressive
navigational system that didn't ensure the correctness of the displayed information.
Cooper also explored alarm clocks, cameras, cars, banks, and even warships.
Cooper blames companies for putting in needless features to provide the illusion of advancement and sophistication to market their products. He also likens acceptance of these products in the trend of computerization to a frog not noticing he is sitting in a slowly boiling pot.

Next, Cooper touches in the incomprehensibility of computer interfaces that don't take the human side operator into consideration. He claims the difficulty in understanding these systems that is apparent in the common "mustachioed" man produces a kind of "technological apartheid."

Cooper also mentions that inconsiderate software also causes economic losses like those found in the "IFE" system on airlines that forced flight attendants to walk up and down the aisle more than necessary. (The flight attendants would just short circuit the system at the start of every flight.)

Cooper then coins the term "Techno Rage" to describe the frustration people experience in using bad computer human interfaces.

Cooper also observes that the tech industry seems to believe that any problems with how difficult computer technology is to use, most of which industry denies, will be solved by more advanced technologies. Cooper claims that this is false, because more advanced and complicated technologies will only further confuse the average everyday user. He proposes the process of building the technology needs to be fixed.

After covering these cases and observations, Cooper comes to his main point:
That the experts and apologists for technology within companies hold the reigns to guiding the development of products and as such, issues of usability and approachability of software for common people are ignored.
In more concisely,
"The Inmates are Running the Asylum."

Cooper ends the chapter by explaining his liberation from the process of programming that allowed him to come the above revelations. Cooper also explains that programmers need to do interaction design before they actually begin to code.

Chapter 2 : Cognitive Friction

Cooper starts this chapter by introducing the idea of "cognitive friction" or the resistance encountered by a human mind when it engages with a complex system of rules that changes as the problem changes. Apparently, objects that enter into meta-states frequently, like a computer, tend to be high in cognitive friction which increases frustration.

Cooper then begins to advocate "design" or, more specifically, "interaction design" which includes all things that directly affect the end user of the software.
Cooper claims this design should be done by dedicated "interaction designers" that can steer the focus of the team from software into an enjoyable end product used by humanity.

Cooper goes on to claims that most design is done unwittingly, by convention or tradition, and most times, the end product isn't even used by those who made it.
The software design usually revolves around decisions of what is easy to produce rather than what is easy to use.

Cooper then discusses the differences between interface and interaction. He likens putting an interface to cover bad software to putting an "Armani suit on Attila the Hun." Essentially, just doing interface design is whitewashing the problem. Instead, Cooper advocates doing behavioral design that influences underlying code structure and outputs that will also feed into the interface. He goes further in saying that conceptual design should be done that examines the values and needs of the user and how those needs should be integrated into the software.

Next, Cooper asserts that cognitive friction is a natural part of software because its immediate use cannot be observed and understood at first glance or preliminary manipulation. The user must commit to an action and feel its effects before it is understood. In other words, its usage cannot be intuited which can make the user feel dumb.

Cooper then explains why software has been so prolific and widely used by painting the image of a dancing bear:
"The wonder isn't that the bear dances well but that the bear dances at all."
The uses of software is both incredibly useful and wondrous, if not cantankerous.
Technology advocates and apologists insist that the "dancing bearware" is great and by necessity complicated and difficult to use due to the intractability of the problem domain, but Cooper argues differently.
He claims that people just accept the apologists explanations while software could all the while be better designed. Hence the source of the cognitive friction is in the maker rather than the creation.

Cooper cites that it's easier to add features than to make software easier to use mostly because software development doesn't have a clear built in negative feedback loop for new features that are usually provided by physics and cost of materials.
This lack of a negative feedback loop leads to software that is packed with useless and confusing features that crowd the interaction space. In a word, bloatware.

Cooper mentions that society can be divided into apologists and survivors, with obvious connections to their preferences and attitudes toward technology.
Apologists are attracted to computers because of the innate difficulty of the technology and the height of the cognitive reward for solving the task.
Survivors, on the other hand, are trapped into using computers. They know what's easy and hard and the find using computers hard and frustrating.

Cooper claims that people react to cognitive friction in the same way:
Use the fewest possible feature you understand.

Finally, Cooper covers the "Euphemism Pyramid" composed of naive users, computer-literate users, and power users. These terms hide the truth of how software developers categorize and judge the people they develop for. These judgments reinforce the "software apartheid" and encourages a view that people should adapt to the technology rather than the developers and technology adapting to the needs of the users.

Mythical Man-Month, The: Essays on Software Engineering, Anniversary Edition
By: Frederick P. Brooks Jr.
Publisher: Addison-Wesley Professional
Pub. Date: August 02, 1995

Chapter 1 : The Tar Pit

In the introductory chapter of Mythical Man-Month, Brooks likens the struggles of software engineering to the struggles of "great beasts" to escape entrapment in a tar pit: The problem is sticky and hard to understand and many have fallen in but few escape the problem they find themselves in despite their girth or skill.

Brooks explains that the development of software that is more than merely a "program" but is also a programming product and system inherently introduces costs, complexities and hence problems that figure into complexity of scheduling of making such software. However, many of these complexities in producing "programming systems products" (that are generalized, tested, and documented) or "programming systems" (that are systems of interacting programs) are often underestimated by programmers.

Brooks ends the introductory chapter by discussing the joys and woes of the "craft" of programming.

The joys include:
The joy of making things.
The joy of useful things for others.
The joy of making complex/intricate/puzzle-like things work.
The joy of learning.
The joy of working in a tractable medium (where there imagination is dominant)

The woes include:
The woe of having to perform perfectly.
The woe of being unable to control the circumstances of the work.
The woe of having to depend on others.
The woe of debugging.
The woe linear of convergence where more difficult bugs take more time to find than the first.
The woe of working on a product that is obsolete on completion.

Chapter 2 : The Mythical Man-Month

In this chapter, Brooks explore the titular problem addressed by the book, namely that software projects are often overschedule and that assigning more men to a problem does not necessarily (and not even in the majority of cases) decreases the time left to finish the project. Brooks asserts that assigning more men to a project may even increase the time to completion because of the need to train and familiarize the new men with the current project as well as increase the time to communicate between the team.

Brooks outlines several "fallacies" that cause project schedules to be underestimated:

The first fallacy is that our ideas are perfect, hence, the implementation of these perfect ideas should encounter only minor difficulties. In other words, we are overly optimistic. Brooks makes an observation that programmers tend to be optimists most likely due to the sometimes frustrating nature in the details of programming that sifts out those that are most focused on the end goal. This tendency leads to underestimates of the amount of time to finish a project.

The second fallacy is that effort corresponds to progress. Brooks cites the man-month myth that by applying more men to a project, or effort, the amount of progress, or time remaining, should correspondingly decrease.
However, Brook states that this is only true if the task being undertaken can be split and assigned among workers with no communication needed between them and that the task has no partitions or expertise needed in implementation.

Brooks makes the recommendation that more time should be allocated to the system for testing (1/4 overall time) and that it's better to allow for more project time than to cut features or add manpower to a project.

Chapter 3 : The Surgical Team

In this chapter, Brooks tackles the problem of how to divide work and coordinate work on large software products where a large team is needed.
He makes the recommendation of putting together a "Surgical Team" where roles and responsibilities have a clear separation and where value can be added to the project without waiting on another roles and where authority is strictly defined.
Because a surgical team is small and the experienced members are put in strategic positions, efficiency and skill sets are maximized rather downplayed under the broad categories and restrictions of management.

The roles include the following:

Surgeon - Chief Programmer

The copilot - less experienced Chief Programmer

The administrator - manages personnel, money, space, and other matters that would otherwise tie up the surgeon

The editor - generates documentation

The secretaries - handles correspondence and non-product files for the editor

The program clerk - Maintains technical records of the team

The toolsmith - Provides tools, libraries, software, etc. for the team

The tester - writes test cases, system tests, and assists with debugging

The language lawyer - finds neat and efficient ways to use the language to do difficult, obscure, or tricky things.

The team organization allows the team to act as one and since all the roles are equal, compromises and different points of view increase the quality and cooperation
of and on the project, respectively.

Brooke closes the chapter with a discussion of how to scale up the method by essentially saying that multiple surgical teams can be created and that the surgeon of each team communicates with each other for coordination.

Discussion:

Extreme Programming:

The extreme programming chapters were repetitive and boring (again).
The entire section on "steering" was already covered in story estimation and the need to prioritize was already emphasized earlier.

The only new idea was the one where using a specific tracker to monitor story was suggested and even then common sense could have been applied in how to select a tracker.

I have nothing else to discuss.

Design of Future Things:

This final chapter of future things was undoubtedly the most speculative but in a strange way, perhaps the most informative. His recommendations for the progression of technology and our way of approaching it was thought provoking and maybe even controversial with his recommendation of conforming to technology.

The revolutions in material science and the convergence of man and machine is particularly thought provoking and images of science fiction masterpieces like "Ghost in the Shell" and "The Matrix" quickly come to mind. It would have been easy for Norman to diverge from this near-future focus into wild predictions of the far of future and the potential of humanity's symbiosis with high technology, but fortunately he resists and keeps his discussion focused.

The discussion on how devices communicate with each other, particularly in terms of recommendation of action for a common user, I think, could be drastically expanded on in another chapter. In light of his descriptions, I think we should minimize the amount of recommendation systems that enter into our lives simply because they are a distraction from what might be called a "natural reality." I think diverging from natural reality is somewhat harmful, mostly because our brains, while malleable, are designed/evolved to be interact with our natural reality and the fact that our expectations in social interaction cannot keep pace with our advances in speed and range of communications technologies.

The Inmates are Running the Asylum:

Cooper has some great insights on the psychology of software developers and industry in general that shouldn't be ignored outright. His advocacy of interaction design before coding is the right approach, I think. This keeps the end user and goal of the system in mind and keeps the developers from designing for just the computer and its needs.

His emphasis of the "software apartheid" is probably a bit extreme and I think people are more adaptable than he gives them credit for. Nonetheless, his focus on designing for people is ultimately correct, in my mind.

His observations on the inherent cognitive friction in software are useful and it leads me to think about how software systems and interfaces could be restructured to suit human cognition and need for affordances like Norman advocated.

Mythical Man-Month:

Reading Brooks' writing is a joy when compared to the other two authors for one principal reason: He writes with a sense and appreciate of art of writing. He knows how to write and to make it enjoyable. He writes with interesting metaphors that entertain without being too wild or that go outside the bounds of comparison.
The information he offers, while in itself is not terribly radical or ground breaking, is written in such a way that it sits well on the palette of your mind.
For example, Brooks could easily have written that underestimating the time to implement a program is because programmers are hopelessly optimistic and bad metrics are used in management. But this would have been dry and boring. Instead, he illuminates the fallacies that cause those problems and slowly reveals the effects of these fallacies as the ones stated above.

The idea of the surgical team was interesting although I might question the necessity of many of the roles, like the language lawyers. Such positions may be out-dated but I'll reserve my judgment given my inexperience.