Properties would work nicely with First-class methods

Method getter = Action.class.getDeclaredMethod("isEnabled", new Class[] { });
Method setter = Action.class.getDeclaredMethod("setEnabled", new Class[] { boolean.class });
boolean fooEnabled = getter.invoke(fooAction, new Object[] { });
setter.invoke(barAction, new Object[] { false });

Method getter = Action#isEnabled()
Method setter = Action#setEnabled(boolean)
boolean fooEnabled = getter.invoke(fooAction, new Object[] { });
setter.invoke(barAction, new Object[] { false });

#(boolean(Action)) getter = Action#isEnabled();
#(void(Action,boolean)) setter = Action#setEnabled(boolean);
boolean fooEnabled = getter.invoke(fooAction);
setter.invoke(barAction, false);

Property<Action,Boolean> property = new MethodsProperty(
    Action#isEnabled(), Action#setEnabled(boolean))
boolean fooEnabled = property.get(fooAction);
property.set(barAction, false);

# posted by Jesse Wilson on Friday, June 29, 2007  2 comments   post a comment

Modelling Properties in Java

/**
 * Models the relationship between two related types, such as
 * the address of a customer or the size of a List.
 *
 * <p>A property is not bound to a particular base object - rather it
 * is shared by all instances of a class.
 *
 * @param <B> the base object type, such as Customer
 * @param <V> the value type, such as an Address or String
 */
public interface Property<B,V> {
  /**
   * Returns the value of this property on the specified object.
   * @throws PropertyNotReadableException
   */
  V get(B baseObject);

  /**
   * Returns the value of this property on the specified object,
   * or the specified default if this property cannot be resolved.
   */
  V get(B baseObject, V defaultValue);

  /**
   * Sets the value of this property on baseObject to newValue.
   * @return the previous value of the property
   * @throws PropertyNotWritableException
   */
  V set(B baseObject, V newValue);

  Class<B> getBaseObjectType();
  Class<V> getValueType();

  /**
   * Returns a brief description of this property such as
   * "address" or "size".
   */
  String toString();
}

/**
 * Mixin for properties that can notify observers when
 * they change.
 */
public interface ObservableProperty<B,V> extends Property<B,V> {
  /**
   * Register the specified listener to receive notification when
   * this property is changed.
   */
  void addPropertyChangeListener(B baseObject, PropertyChangeListener listener);

  /**
   * Deregister the specified listener from receiving notification
   * when this property is changed.
   */
  void removePropertyChangeListener(B baseObject, PropertyChangeListener listener);
}

Thoughts on Java as the configuration language for Guice

public class PizzaOrdering implements Module {
  public void configure(Binder binder) {
    // tell Guice that whenever the code needs an implementation of
    // my CallInOrderHandler interface, the WebCallInOrderHandler 
    // shall be used
    binder.bind(CallInOrderHandler.class).to(WebCallInOrderHandler.class);

    // tell Guice that whenever the code needs an OrderEditor, they
    // should be provided with the same WebOrderEditor for the duration
    // of their current phone call
    binder.bind(OrderEditor.class)
        .to(WebOrderEditor.class)
        .in(PhoneCallScope.class)
  }
}

<binding key="com.publicobject.pizza.CallInOrderHandler" 
    target="com.publicobject.pizza.ui.WebCallInOrderHandler">
<binding key="com.publicobject.pizza.OrderEditor" 
    target="com.publicobject.pizza.ui.WebOrderEditor"
    scope="com.publicobject.pizza.request.PhoneCallScope">

The only way for tools to read the configuration is to execute it.

public class PizzaDelivery implements Module {
  public void configure(Binder binder) {
    String strategy = System.getProperty("DeliveryDriverQueueingStrategy");
    if ("FirstInFirstOut".equals(strategy)) {
      binder.bind(DeliveryDriverQueueingStrategy.class)
          .to(FifoDeliveryDriverQueueingStrategy.class);
    } else if ("FirstInLastOut".equals(strategy)) {
      binder.bind(DeliveryDriverQueueingStrategy.class)
          .to(FiloDeliveryDriverQueueingStrategy.class);
    } else {
      logger.warn("No queueing strategy!");
    }

AssistedInject, an easier way to help the Guice Injector build objects

public class RealPayment implements Payment {
  public RealPayment(
        CreditService creditService,  // from the Injector
        AuthService authService,  // from the Injector
        Date startDate, // from the instance's creator
        Money amount); // from the instance's creator
  }
  ...
}

public interface PaymentFactory {
  public Payment create(Date startDate, Money amount);
}

public class RealPaymentFactory implements PaymentFactory {
  private final Provider<CreditService> creditServiceProvider;
  private final Provider<AuthService> authServiceProvider;
  public PaymentFactory(Provider<CreditService> creditServiceProvider,
      Provider<AuthService> authServiceProvider) {
    this.creditServiceProvider = creditServiceProvider;
    this.authServiceProvider = authServiceProvider;
  }
  public Payment create(Date startDate, Money amount) {
    return new RealPayment(creditServiceProvider.get(),
      authServiceProvider.get(), startDate, amount);
  }
}

   bind(PaymentFactory.class).to(RealPaymentFactory.class);

public class RealPayment implements Payment {
  @AssistedInject
  public RealPayment(
        CreditService creditService,
        AuthService authService,
        @Assisted Date startDate,
        @Assisted Money amount);
  }
  ...
}

bind(PaymentFactory.class).toProvider(
    FactoryProvider.newFactory(PaymentFactory.class, RealPayment.class));

1. Annotate the constructor and assisted parameters on the implementation class (such as RealPayment.java)
   
2. Create a Factory interface with a create() method that takes only the assisted parameters. Make sure they're in the same order as in the constructor
   
3. Bind that FactoryInterface to our FactoryProvider interface.
   

Why dreamhost.com rules for domain hosting

Java language tweak: protected switch

public enum Office {
  CALGARY, REGINA, TORONTO, BERLIN;
}

public CurrencyCode getCurrencyForPayingEmployees(Office office) {
  switch(office) {
    case CALGARY:
    case REGINA:
    case TORONTO:
      return CurrencyCode.CAD;
    case BERLIN:
      return CurrencyCode.EUR;
  }
}

    default:
      throw new AssertionError();

public CurrencyCode getCurrencyForPayingEmployees(Office office) {
  protected switch(office) {
    case CALGARY:
    case REGINA:
    case TORONTO:
      return CurrencyCode.CAD;
    case BERLIN:
      return CurrencyCode.EUR;
  }
}