I’ll get my coat

My most embarrassing client-facing moment to date: the time when I sat down on a beanbag a bit too close to the movable partition behind me and knocked it over into another partition that was behind the first one, which also went down, taking out a large rubbish bin as it went. The whole event taking place so slowly that the other people present had time to crack jokes about it while it was still happening.

Advertisements

Agile methods and Lean Manufacturing

Agile methods are all about delivering maximum business value, and minimum risk. Lean manufacturing is about reducing cycle time (takt), and waste (muda). Its focus is on customer pull. From this idea flow concepts like just-in-time delivery, and inventory reduction. The ultimate lean system being one where a customer order arrives at the point of sale, and the instructions flow all the way back to the point of obtaining the raw materials. The necessary tasks to create the desired item take place, flowing back down the chain to the customer, who receives their product. No batching, no storage, just value creation.

Lean manufacturing principles applied to the software delivery process lead inexorably to something that looks very much like the ideal agile team: Customer requests feature, team implements feature, one-click automated build-test-deploy cycle takes place, feature is live.

You might argue that such an idealised vision is oversimplification to the point of absurdity, but it provides an excellent target (agilists might say ‘test’), against which to measure process improvement efforts and assess current state. Very pleasing.

Java 1.5 gets attributes

Something that is new in 1.5, and could potentially be very cool is its support for metadata, which (based on a brief scan) looks a lot like .Net attributes, and possibly even more powerful. The java site has this to say:

Metadata

This language feature lets you avoid writing boilerplate code under many circumstances by enabling tools to generate it from annotations in the source code. This leads to a “declarative” programming style where the programmer says what should be done and tools emit the code to do it. Also it eliminates the need for maintaining “side files” that must be kept up to date with changes in source files. Instead the information can be maintained in the source file.
Refer to JSR 175.

Annotations are also used to implement the ‘override’ functionality of .Net, as this snippet from the JSR states:

This annotation type allows the programmer to declare his belief that a method
declaration overrides a superclass method:

@Overrides public boolean equals(Foo that) { … }

The compiler checks whether method actually overrides a superclass method,
and reports an error if it does not, nipping the problem in the bud.