Java 6 and Mac OS X 10.5

Apple’s decision to abandon (or postpone, for all we know) work on Java 6 was easy. Some of the most important software for the Mac depends on Carbon. No important software for the Mac depends on Java.

# posted by Jesse Wilson on Tuesday, October 30, 2007  0 comments   post a comment

Implementing equals() is hard

public class Product {
  private final Id id;
  private final String description;
  private final Money price;

  ...

  public boolean equals(Object other) {
    if (!(other instanceof Product)) {
      return false;
    }

    Product otherProduct = (Product) other;
    if (id != null && otherProduct.id != null) {
      return id.equals(otherProduct.id);
    } else {
      return description.equals(otherProduct.description)
          && price.equals(otherProduct.price);
    }
  }
}

  /* reflective */
  assertTrue(a.equals(a));

  /* symmetric */
  assertTrue(a.equals(b) == b.equals(a));

  /* transitive */
  if (a.equals(b) && b.equals(c)) {
    assertTrue(a.equals(c));
  }

Transitivity is hard

  Product a = new Product(5, "Large Pepperoni", Money.usd(11));
  Product b = new Product(null, "Large Pepperoni", Money.usd(11));
  Product c = new Product(6, "Large Pepperoni", Money.usd(11));

Consequences

The Fix

# posted by Jesse Wilson on Tuesday, October 30, 2007  6 comments   post a comment

A simple pattern for avoiding NullPointerExceptions

public interface StoreLocator {
  /**
    * Returns a store nearest to {@code address}, or {@code null}
    * if there are no stores within delivery range of the address.
    */
  PizzaStore findNearbyStore(Address address);
}

Why returning null is annoying

  public Receipt createReceipt(Order order) {
    ...

    PizzaStore closestLocation 
        = storeLocator.findNearbyStore(order.getDeliveryAddress());
    if(closestLocation == null) {
      throw new IllegalArgumentException("No stores nearby!");
    }
    if (!closestLocation.equals(order.getStoreAddress())) {
      receipt.addMessage("Next time you order a pizza, consider"
          + " our closer %s location", closestLocation);
    }

    return receipt;
  }

Why returning null is dangerous

  public Order createOrder(Address toAddress, List<LineItem> lineItems) {
    PizzaStore store = storeLocator.findNearbyStore(toAddress);
    return new Order(toAddress, lineItems, store);
  }

A simple fix - two methods

public interface StoreLocator {
  /**
    * Returns a store nearest to {@code address}.
    * @throws IllegalArgumentException if there are no stores
    *     within delivery range of the address.
    */
  PizzaStore findNearbyStore(Address address);

  /**
    * Returns a store nearest to {@code address}, or {@code defaultValue}
    * if there are no stores within delivery range of the address.
    */
  PizzaStore findNearbyStore(Address address, PizzaStore defaultValue);
}

  public Address getCustomerServiceAddress(Address customerAddress) {
    return storeLocator.findNearbyStore(
        customerAddress, PizzaStores.HEAD_OFFICE).getAddress();
  }

# posted by Jesse Wilson on Monday, October 29, 2007  1 comments   post a comment

My favourite bookmarklets

← go to the "previous" page. This works for pages with numbers in the URLs, like Engadget or multi-page articles. From JWZ.

↑ go "up" in the URL hierarchy. In some blogs, this takes you from the current post to the blog itself. From JWZ.

→ go to the "next" page. From JWZ.

μ create a tinyurl for this page.

X-ray examine the CSS path of the elements on this page. This is a fully-featured program that allows you to debug CSS issues. From westciv.

≈ translate the current page into English. From Google.

JS execute arbitrary JavaScript. Use this to prototype your own bookmarklets!

# posted by Jesse Wilson on Monday, October 29, 2007  0 comments   post a comment

Catching unchecked exceptions is fragile

  /** 
   * @return the directions, or {@code null} if they are unavailable.
   */
  public Directions tryToLookupDirections(Address from, Address to) {
    try {
      MappingSession session = mappingService.openSession();
      MappingResponse response = session.request(
          new DirectionLookupRequest(from, to));
    } catch(MappingServiceUnreachableException e) {
      logger.log(Level.WARNING, e.getMessage(), e);
      return null;
    }
  }

  /** 
   * @return the directions, or {@code null} if they are unavailable.
   */
  public Directions tryToLookupDirections(Address from, Address to) {
    MappingSession session = mappingService.openSession();
    try {
      MappingResponse response = session.request(
          new DirectionLookupRequest(from, to));
    } catch(MappingServiceUnreachableException e) {
      logger.log(Level.WARNING, e.getMessage(), e);
      return null;
    } finally {
      session.close();
    }
  }

• If MappingServiceUnreachableException was a checked exception, I'd find out about my blunder as I make it. If I'm using a good IDE, I find out before I even save the file.


• If I have complete test coverage for the exceptional case, I'll find out about my blunder the next time that test is run - probably within a few minutes.


• If I have only sunny-case test coverage, I won't find out about my blunder until the next time that the mapping service is unavailable.

# posted by Jesse Wilson on Thursday, October 25, 2007  1 comments   post a comment

Ten blogs for your feedreader

Ars Technica: tech news
Eric Burke: Java observations
Cédric Beust: Java developer productivity
Neal Gafter: the Java language
Stephen Colebourne: Java APIs
John Gruber: the Mac
Daniel Lyons: the Mac, but snarky
Tim O'Reilly: next year's technology
Joel Spolsky: running an small software shop
Raymond Chen: old school Windows

# posted by Jesse Wilson on Sunday, October 21, 2007  0 comments   post a comment

Don't let consistency rule your APIs

public enum Status {
  PENDING,
  PREPARATION_IN_PROGRESS,
  PREPARED,
  DELIVERY_IN_PROGRESS,
  DELIVERED;
  CANCELLED,

  public boolean isFinished() {
    return this == CANCELLED || this == DELIVERED;
  }
}

interface Stack<T> {
  /**
   * Adds {@code value} to the stack.
   */
  void push(T value);

  /**
   * Removes and returns the most recently pushed value in the stack.
   * @throws StackEmptyException if the stack contains no elements
   */
  T pop();
}

public class InputStream {
  int read() throws IOException;
  int read(byte[] b) throws IOException;
  void close() throws IOException;
}

  InputStream in = null;
  try {
    in = openInputStream();
    return parse(in);
  } catch(IOException e) {
    throw new ApplicationException("Failed to read input", e);
  } finally {
    try {
      if (in != null) {
        in.close();
      }
    } catch(IOException ignored) {
    }
  }

# posted by Jesse Wilson on Tuesday, October 16, 2007  1 comments   post a comment

Don't fly AirTran

I pleaded, "But it's 6:10!"

The guy, "But your seat has already been sold. When you weren't here at 6:10, we sold it to someone else."

I pleaded, "But it's still 6:10!"

So now I'm riding "standby" on their 1:53pm flight. That means that they've overbooked me on that flight and I only get to ride if they shaft somebody else.

Don't fly AirTran, they don't value your time.

# posted by Jesse Wilson on Monday, October 15, 2007  1 comments   post a comment

Airport WiFi thinks my newsreader is a virus

Anomalous Behavior Detected - Request Blocked

Your computer was automatically blacklisted (blocked) due to an abnormal amount of activity. It is possible that your computer is infected with a worm or virus.

# posted by Jesse Wilson on Friday, October 12, 2007  1 comments   post a comment

Spammy Java

Minimalist:

  public static <T> Comparator<T> reverse(final Comparator<T> forward) {
    Preconditions.checkNotNull(forward, "forward");
    return new Comparator<T>() {
      public int compare(T a, T b) {
        return forward.compare(b, a);
      }
    };
  }

Complete:

  /**
   * Returns a comparator that's the reverse of {@code forward}.
   *
   * @param forward the forward comparator
   * @return the reversed comparator
   * @throws NullPointerException if {@code forward} is null
   */
  public static <T> Comparator<T> reverse(final Comparator<T> forward) {
    return new ReverseComparator<T>(forward);
  }

  /**
   * A comparator that reverses another comparator.
   *
   * @param <T> the type to compare
   */
  private static class ReverseComparator<T> implements Comparator<T> {
    private final Comparator<T> forward;

    public ReverseComparator(final Comparator<T> forward) {
      super();
      Preconditions.checkNotNull(forward, "forward");
      this.forward = forward;
    }

    @Override
    public int compare(final T a, final T b) {
      return forward.compare(b, a);
    }
  }

# posted by Jesse Wilson on Monday, October 08, 2007  3 comments   post a comment

Considering Guice: Explicit dependencies

/**
 * Guice version.
 */
public class RealOrderService implements OrderService {

  private final ReadableDuration maxTravelDuration;
  private final Distance maxTravelDistance;
  private final Geography geography;
  private final AddressBlacklist addressBlacklist;
  private final WorkSchedule workSchedule;

  @Inject
  public RealOrderService(
      @Named("MaxTravelDuration") ReadableDuration maxTravelDuration, 
      @Named("MaxTravelDistance") Distance maxTravelDistance, 
      Geography geography,
      AddressBlacklist addressBlacklist,
      WorkSchedule workSchedule) {
    this.maxTravelDuration = maxTravelDuration;
    this.maxTravelDistance = maxTravelDistance;
    this.geography = geography;
    this.addressBlacklist = addressBlacklist;
    this.workSchedule = workSchedule;
  }

  public Set<Reason> validate(Order order) {
    Set<Reason> reasons = new HashSet<Reason>();

    Store store = order.getStore();

    if (order.isDelivery()) {
      Address deliveryAddress = order.getDeliveryAddress();
      Address storeAddress = store.getAddress();
      Route route = geography
          .calculateRoute(deliveryAddress, storeAddress);


      if (!addressBlacklist.isAddressOk(deliveryAddress)) {
        List<Note> blacklistNotes = addressBlacklist.getNotes(deliveryAddress);
        reasons.add(new Reason(ReasonId.BLACKLISTED_ADDRESS, blacklistNotes));
      }

      Duration travelDuration = geography
          .calculateTravelDuration(route, order.getQuotedArrivalTime());
      if (travelDuration.isLongerThan(maxTravelDuration)) {
        reasons.add(new Reason(ReasonId.TRIP_DURATION_TOO_LONG, travelDuration));
      }

      Distance travelDistance = route.getDistance();
      if (travelDistance.isLongerThan(maxTravelDistance)) {
        reasons.add(new Reason(ReasonId.TRIP_DISTANCE_TOO_LONG, travelDistance));
      }

      List<User> onDuty = workSchedule.getPeopleOnDuty(
          store, order.getQuotedArrivalTime());
      List<User> deliveryPersons = selectUsersInRole(onDuty, Role.ORDER_DELIVERY);
      if (deliveryPersons.isEmpty()) {
        reasons.add(new Reason(ReasonId.NO_DELIVERY_PERSONS_ON_DUTY));
      }
    }

    ...

    return reasons;
  }

  ...

}

/**
 * Standard version.
 */
public class RealOrderService implements OrderService {

  private final ReadableDuration MAX_TRAVEL_DURATION
      = Minutes.minutes(15).toStandardDuration();
  private final Distance MAX_TRAVEL_DISTANCE
      = Distance.forKilometers(10);
















  public Set<Reason> validate(Order order) {
    Set<Reason> reasons = new HashSet<Reason>();

    Store store = order.getStore();

    if (order.isDelivery()) {
      Address deliveryAddress = order.getDeliveryAddress();
      Address storeAddress = store.getAddress();
      Route route = GeographyFactory.getInstance()
          .calculateRoute(deliveryAddress, storeAddress);

      AddressBlacklist addressBlacklist = AddressBlacklistFactory.getInstance();
      if (!addressBlacklist.isAddressOk(deliveryAddress)) {
        List<Note> blacklistNotes = addressBlacklist.getNotes(deliveryAddress);
        reasons.add(new Reason(ReasonId.BLACKLISTED_ADDRESS, blacklistNotes));
      }

      Duration travelDuration = GeographyFactory.getInstance()
          .calculateTravelDuration(route, order.getQuotedArrivalTime());
      if (travelDuration.isLongerThan(MAX_TRAVEL_DURATION)) {
        reasons.add(new Reason(ReasonId.TRIP_DURATION_TOO_LONG, travelDuration));
      }

      Distance travelDistance = route.getDistance();
      if (travelDistance.isLongerThan(MAX_TRAVEL_DISTANCE)) {
        reasons.add(new Reason(ReasonId.TRIP_DISTANCE_TOO_LONG, travelDistance));
      }

      List<User> onDuty = WorkScheduleFactory.getInstance().getPeopleOnDuty(
          store, order.getQuotedArrivalTime());
      List<User> deliveryPersons = selectUsersInRole(onDuty, Role.ORDER_DELIVERY);
      if (deliveryPersons.isEmpty()) {
        reasons.add(new Reason(ReasonId.NO_DELIVERY_PERSONS_ON_DUTY));
      }
    }

    ...

    return reasons;
  }

  ...

}

Be conservative in what you accept and conservative in what you send

  public void setDeliveries(List<Delivery> deliveries) {
    if (deliveries == null) {
      deliveries = Collections.emptyList();
    }

    this.deliveries = Collections.unmodifiableList(
        new ArrayList<Delivery>(deliveries));
  }

  public void setDeliveries(List<Delivery> deliveries) {
    if (deliveries == null) {
      throw new NullPointerException("deliveries");
    }

    this.deliveries = Collections.unmodifiableList(
        new ArrayList<Delivery>(deliveries));
}

# posted by Jesse Wilson on Monday, October 01, 2007  4 comments   post a comment