How to be effective in agile way ?

During my thinking of agile and how I can be happy at work (thanks to flow book ) I found 3 ideas that guide creation of a lot of lean/agile practices:

• inspect and adapt - understand where you are and what can be changed. Retrospectives and demo are good example of it implemented.

• art of possible - what can be done better or automated or ignored? Facing your challenges provoke your brain to work on solution, even unconsciously

• timeframe - plan is not a plan without reasonable timing. that's why proper stand-up meeting and iterations timing give you a lot of information to think about and be in touch with reality. Pomodoro technique is a great example of this on personal level. 

Details on these practices will be discussed in later posts.
Interesting question here is how personal practices corelate with team practices, for example pair programming and TDD ? And how personal effectiveness causes/permits team effectiveness?

I really should mention The 3 Pillars of Personal Effectiveness in this post, very interesting reading in GTD category.

Inheritance is evil, and must be destroyed

Good article about inheritance  - http://berniesumption.com/software/inheritance-is-evil-and-must-be-destroyed/.
Mix-in and Strategy are great replacements for it.

BDD Beautiful development

In next couple of weeks I'm going to try BDD for java project - http://easyb.org/.
This tool looks promising compared to existing in-house solutions.

How to write javadoc tips

Worst documentation for code is one that repeats code. Some companies want to avoid this pitfall by implementing "no javadoc" rule (I'm talking about java). This is wrong.
Using following tips (hopefully) will help you to produce meaningful documentation for code:

•  Use questions in templates for documentation. It's more mind stimulating to answer "What does this class do ?" than replace template "Write description of the class"
• Write CRC in documentation. CRC means class-responsibility-collaborator data. Example:
• class: What is it ?
• responsibility: What and when does it work, what valuable does it do ?
• collaborator: What classes/modules uses this class ? What classes/modules is used by it ?
• Example of use. Basic usage scenario in javadoc is most useful thing. It's got noticed on first place (almost every class in JDK has one).
• Design By Contract: For both class and method it's important to know:
• Precondition: 
• When it's legal to use class/method?
•  What is a valid types and boundary conditions for arguments? Null, string format, data range
• What is true about method/class execution (thread safe, can produce exception, require external resources, linked with other methods/classes)
• What is possible outcome ? (Empty array, value object)

Last, a bit vague advice -  do not repeat class/method name. Describe code in business terms, using different words than in code. If you can-not do it or method is pretty obvious - don't write it.

Translator pattern

One common task in banking is translating from one form to another. I couldn't find an effectife solution for this problem, but TranslatorPattern offers interesting approach.
I've used similar functionality in Amoeba utility classes:

 private static interface Amoeba<Value> {

  boolean consume(Amoeba<Value> amoeba);

  Value produce() throws Exception;
 }

 private static class AmoebaUtils {

  static <Value> boolean populate(Collection<Amoeba<Value>> colony, Amoeba<Value> nominate) {
   for (Amoeba<Value> citizen : colony) {
    if (citizen.equals(nominate)) {
     return citizen.consume(nominate);
    }
   }
   return colony.add(nominate);
  }

  static <Value> Collection<Value> produce(Set<Amoeba<Value>> colony) throws Exception {
   Set<Value> values = new HashSet<Value>();
   for (Amoeba<Value> citizen : colony) {
    values.add(citizen.produce());
   }

   return values;
  }
 }



This gives ability to absorb source notes by related destination nodes, providing natural grouping and translating of information. This is kind of builder and translator, with non-linear rules of transformation (source node != dest node).

List of Lists

Task: to order input data according 2 integer keys.
Example: we have bunch of options. Options have indexes and legs. Legs have indexes and other useful information.
Question: how to extract one type of information from legs?
Answer:
...
private final List<List<FinDate>> expiryDateByOptionAndLeg;
expiryDateByOptionAndLeg = new ArrayList<List<FinDate>>(size){
...
@Override
public List<FinDate> get(int index) { 
 List<FinDate> rez = null;
  rez = super.get(index);
  if(rez == null) {
   rez = new ArrayList<FinDate>(2);
   add(index, rez);
  }
  return rez;
}
};
...
  expiryDateByOptionAndLeg.get(optionsIndex).set(legIndex, expiryDate);



Answer: To use approach suggested in ThreadLocal class javadocs. In this way we receive clear 2-indeger index without need to create list in business code. Similar approach could be applied to Maps.
It's simpler than creating  separate business object and still readable and expressive.

Api Design: Key vs Session

During discussion of our new API an question come up, why session is better than a simple key.
Session concept is to have per connection object with details on customer, it's preferences, etc.
Key concept is to have passive key and number of services that uses it.
I came up with following:

Session	Key
Holds request specific data	Need to hold request specific data in api objects
More agile approach, you can make you session active, have one master instance for actions or session-specific actors	Managing class and a collection of keys are needed for two way communication
Visible list of services available	You should knew about service existence before use it
It's complex to fake system	It's easy to confuse keys

It's subject to update. Please place you thoughts about it.