Just make the code look like what you just told me.
I'm friendly but not at all helpful while I do this.
Again, I ask them for their impressions.My comments is that clients should be opportunistic: if they understand some shared semantic (like a RESTful shopping API or task manager) then they can automate some interactions.Should this idea be extended to the rest of non-user facing resource-oriented applications? I don't think so. Here is why.
The idea of hypermedia embedding all the action controls necessary to interact with the server works well for an arbitrary number of universal clients interacting with a given server. In this case, the server offering a set of resources specifies all the ordering/interaction rules within the representation. Most application clients, on the other hand, interact with more than one server, and the ordering constraints can not be set by any given server. The clients know how to compose applications out of resources offered by various servers, and each client needs to be able to exercise control over composition. To be able to exercise such a control, client applications can not be universal, and the benefits that John lists above cannot be completely realized.
when no human is in the loop, you need a shared understanding between the resource consumer and the resource (provider)The only viable choices JJ then describes (WSDL or WADL) do indeed provide a partial solution to coding shared understanding, but not evolution.
String overrideMessage;
final String defaultMessage="Howdy";
public String sayHello(String name) {
String s=null;
if (overrideMessage!=null)
s = overrideMessage;
else
s = defaultMessage;
return s+" "+name;
}
Option<String> overrideMessage=none();
final String defaultMessage="Howdy";
public String sayHello(String name) {
return overrideMessage.or(defaultMessage)+" "+name;
}
public class Options {
/**
* An Option can be either full (Some<T>) or empty (None).
* Instead of passing/returning nulls use an Option
*/
public abstract static class Option<T> {
public final boolean some;
public final boolean none;
private Option(boolean some) {
this.some = some;
this.none = !some;
}
abstract public T val();
public T or(T defaultResult) {
if (some)
return val();
else
return defaultResult;
}
}
/**
* Placeholder for empty
*/
public static class None<T> extends Option{
private None() {
super(false);
}
public T val() {
throw new NullPointerException("Can't dereference a Nonevalue");
}
}
/**
* A Holder for some value (never null)
*/
public static class Some<T> extends Option{
private final T val;
private Some(T val) {
super(true);
this.val = val;
}
public T val() {
return val;
}
}
/**
* Use this when not sure if value is present or null
*/
public static <T> Option<T> option(T value) {
if (value==null)
return none();
else
return some(value);
}
/**
* Use this to wrap a non-null value
*/
public static <T> Some<T> some(T value) {
return new Some<T>(value);
}
@SuppressWarnings("unchecked")
private final static None NONE=new None();
/**
* Use this when you don't have a value
*/
@SuppressWarnings("unchecked")
public static <T> Option<T> none() {
return NONE;
}
}
