Not only will it protect Hollywood from the downside of the bill, it will also create new barriers to entry, making it harder for amateurs to create and distribute video content — and just at the moment when technology seems to be enabling high-quality amateur video distribution.

Who is a professional is a horrendous problem for reasons that nobody has mentioned yet: what about independent low budget filmakers? Will it be illegal to sell professional equipment to them because they “aren’t really professionals” or will they be chained down by rediculous DRM schemes?

import junit.framework.*;
import java.lang.reflect.*;
import java.util.Arrays;
/*
 * DoNothingTest.java
 * JUnit based test
 *
 * Created on January 12, 2006, 10:35 PM
 */

public class DoNothingTest extends TestCase {
    
    public DoNothingTest(String testName) {
        super(testName);
    }

    protected void setUp() throws Exception {
    }

    protected void tearDown() throws Exception {
    }
    
    public static interface BunchaMethods {
        void doVoid();
        int getInt();
        String getString();
        Integer getInteger();
        Object getObject();
        int[] getIntArray();
    }

    public void testNewInstance() {

        BunchaMethods b = (BunchaMethods) DoNothing.newInstance(BunchaMethods.class);
        
        b.doVoid(); // nothing happens!
        
        assertEquals( 0, b.getInt());
        
        assertEquals( null, b.getString());
        assertEquals( null, b.getInteger());
        assertEquals( null, b.getObject());
        assertEquals( null, b.getIntArray());
    
    }
    
}

/*
 * DoNothing.java
 *
 */

import java.lang.reflect.*;
import java.util.Arrays;

/**
 * Creates a dynamic proxy that simply does nothing and returns null
 * or "0", when any of its methods are called.
 */
public class DoNothing implements InvocationHandler {
    
    /**
     * Creates a do-nothing proxy that implements all the interfaces.
     */
    public static Object newInstance(Class[] interfaces) {
        return Proxy.newProxyInstance(DoNothing.class.getClassLoader(), interfaces, new DoNothing());
    }
    
    /**
     * Creates a do-nothing proxy that implements one interface.
     */
    public static Object newInstance(Class iface ) {
        return newInstance( new Class[]{iface});
    }


    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Class returnType = method.getReturnType();
        
        // if the method isn't supposed to return anything,
        // return null
        if(returnType == void.class) {
            return null;
        }
        
        // if we have a return value, return whatever it is
        // that new arrays of our return type are filled with.
        // this is a convenient way to get "0" as the right
        // kind of primitive, or null for objects, in one
        // line of code.
        return Array.get( Array.newInstance(returnType,1), 0);
    }
    
    
}

Uniform is a java class library supporting runtime supertyping. In practice, that makes it somewhat like Latent Typing or Duck Typing.

Both Java and C# share the same model of pure interface types. You declare a pure interface by going interface Mailable, then you can declare you implement it with class Customer implements Mailable (in Java). A class may implement any number of pure interfaces.

One of the things this model ignores is that you have implicit interfaces whenever you have a class. The implicit interface Customer is all the public members declared on Customer. One thing that neither Java nor C# allow you to do is to implement an implicit interface - you cannot write class ValuedCustomer implements Customer.

PIC_0198, originally uploaded by jeff_robertson.

Most unfortunate sign ever?