While Wikipedia itself does not run ads, they are the most-scraped site on the web. Scrapers need content — any content will do — in order to carry ads from Google and other advertisers. This entire effect is turning Wikipedia into a generator of spam

From: Jeff Robertson
Sent: 12/12/2005 12:40 PM
Subject: Rant: don't send screenshots of textual information..

If you're ever trying to email someone a list of files, etc., please don't do so by taking a screenshot of explorer showing those files. This is quite possibly the next-to-least-usable way to convey the information, second only to recording an MP3 of yourself singing the file names to the tune of "I am the very model of a modern major
general.." and emailing that.

Not naming any names. That is all.

cookie theft demonstration, originally uploaded by jeff_robertson.

/work

This is some of what you're going to miss seeing if you don't come to my security presentation tommorrow.

The Federal Financial Institutions Examination Council (FFIEC) has issued the attached guidance, “Authentication in an Internet Banking Environment.” For banks offering Internet-based financial services, the guidance describes enhanced authentication methods that regulators expect banks to use when authenticating the identity of customers using the on-line products and services. Examiners will review this area to determine a financial institution’s progress in complying with this guidance during upcoming examinations. Financial Institutions will be expected to achieve compliance with the guidance no later than year-end 2006.

In the U.S., federal regulators
are now requiring banks to have at least two-factor authentication with
their websites by the end of 2006. The Federal Financial Institutions
Examination Council (made up of the FDIC - Federal Deposit Insurance
Corp, the U.S. Federal Reserve, the U.S. Comptroller the Currency, and
others) has very recently issued a press release as well as specific, non technology-specific guidance (PDF) on the need for two-factor authentication. It's an idea being sold to banks and the public as a way to address identity theft in a supposedly proactive manner.

The Element Construction Set is a Java API for generating elements for various markup languages it directly supports HTML 4.0 and XML, but can easily be extended to create tags for any markup language. It is designed and implemented by Stephan Nagy and Jon S. Stevens.

Ok, I'm about to finally jump on the bandwagon and try Firebird.

I first tried Mozilla somewhere around Milestone 13. At first I found that the Windows version was noticeably slower than MSIE, at least on the 500mhz, 128mb of RAM that I had at the time. And I don't just mean startup time, I mean everything was slow (you could actually speed it up appreciably by using the classic theme instead of modern). It actually didn't take many more milestones after that to close this gap, though.

I've been using Mozilla regularly since approximately 0.8. For a while I actually used it on a 133mhz machine running Red Hat 6.2. That was just asking for trouble, and I got some of it in the form of long startup times and occasional crashes, but it did HTML and CSS so much better than Netscape 4 that it was worth it.

Around 1.1 time was when I finally decided to forget how to use MSIE and just use Mozilla for all my browsing except for the few intranet applications that use ActiveX controls and stuff like that.

I guess my point is, except for those early experiences I've never found myself saying "this thing is bloated! I want a smaller browser!". So I just never got the point of the Phoenix/Firebird project. But if that's the way that the Mozilla winds are blowin', I guess I'll have to go along.

Firebird just finished downloading; I guess I'll go install it.

I am convinced that Gilmore Girls carries a secret anti-big-government, pro-free-enterprise message.

Proof? Which secondary character is more positively protrayed: Taylor, who constantly tries to use the organs of town government to further his own agenda; or Luke, who just wants to be left alone to run his restaurant in peace?

Watch this space. I may actually get bored enough to write an essay on this topic fit for submission as a 10th grade term paper.

Because the U.S. chose to get involved in the affairs of Iraq, we now have a moral obligation to set up an actual free society there. If we replace one tyranny with another, we have betrayed our own highest principles. Ways in which we could fail include, but are by no means limited to, the following:

If we install or allow the formation of some kind of a government where "tribal" membership is very important and tribal leaders have a lot of influence, you can bet that we will just be paving the way for the warlords and their private/family/tribal armies to carve up the place in a few years.

If we install or allow the formation of any kind of theocracy, we will produce a government that will eventually be much more likely to attack the U.S. than the one we just removed.

If we set up a government that has no actual support from its people, then it will either require our continuous military help just to stay in power, or resort to totalarian measures of its own, or fall apart and be replaced by something much worse. Or all three, in that order.

If we decide to keep Iraq under our thumb and run their affairs for an indefinate time, that would be naked colonialism, a repudiation of the principles of the American revolution itself (unfortunately, far from the first in our history).
me

I don't usually say much about war or politics, either here or in email or on usenet. But I don't think this would be a real weblog if I didn't say something now.

Once the shooting starts (and it may have already started by the time you read this), the anti-war folks may as well go home and start working on your signs and slogans for the next big crisis. If protesting didn't do anything to prevent the war (and it didn't), then it sure isn't going to end the war or bring our troops home one day sooner. In the event that the war goes badly (however you define that), no "I told you so!" smart-assed-ness will accomplish anything except to make you look like pseudo-traitors who enjoy seeing the U.S. fail in every way possible.

On the other side, making a spectacle of pouring French wine down the drain and boycotting the Dixie Chicks doesn't accomplish anything except to make the people doing these things look like a bunch of ignorant medieval peasants burning some hated person in effigy. In the event that the war goes well (however you define that), no "I told you so!" smart-assed-ness will accomplish anything except to make you look like bloodthirsty hooligans who enjoy watching your military smash and destroy other countries as if it were all some kind of spectator sport.

If the Iraqis surrender quickly, this could be a short and relatively bloodless war. If they put up a fight, it may or may not be short, but it will certainly not be bloodless. I don't know which of these is going to happen. I do know that the war itself is out of my hands and its out of yours, too. What is still very much in our hands is how we behave towards each other during and after.
me

The Wang systems had similar problems with charcter sets, so much so that not only were there "characters" that could not be generated from the keyboard, they also had caracters that could not be represented by an 8-bit hexadecimal code.

Comic strips are moving toward a primordial goo rather than away from it.
Bill Watterson

Find out why you should use stored procedures to build your Java persistence layer instead of embedded SQL, entity beans, or tools such as Hibernate. Then learn how to do it.

In 2001 Microsoft made a documentary film celebrating the creation of Windows XP, which remains the latest full update of Windows. When Mr. Allchin previewed the film, it confirmed some of his misgivings about the Windows culture. He saw the eleventh-hour heroics needed to finish the product and get it to customers. Mr. Allchin ordered the film to be burned.

In this article I will show you the code of a simple servlet. This servlet accepts just one attribute via the POST method. An equally simple HTML page consisting of a text area and a submit button is written to interact with it. Yet despite the simplicity of these two components, what we will have is a powerful tool to interactively analyze the state of any web application.

Absinthe is a gui-based tool that automates the process of downloading the schema & contents of a database that is vulnerable to Blind SQL Injection.

Absinthe does not aid in the discovery of SQL Injection holes. This tool will only speed up the process of data recovery.

To what extent is (or isn't) investor confidence shaken? In other words, why is it the case that information security incidents do not appear to have a greater impact on both investor confidence as well as the public at large? To phrase the question in financial terms: why isn't the top line effected more than it is? To poignantly highlight this phenomena we ask: If 40 million customer credit card numbers are exposed in a security breach at the credit card processor CardSystems , why do a significant number people not cancel their Visa and/or Mastercard?

4th floor hallway of founders hall, originally uploaded by jeff_robertson.

This is the top floor from which the aforementioned stairs are (one of) the escape routes. Obviously built out in recent times in space that used to just be attic. Very out of place; almost like being on a spaceship . Check out all those metal doors on the right wall.

stairwell in founders hall, royal holloway, egham, england, originally uploaded by jeff_robertson.

These narrow spiral metal stairs are an officially designated fire escape route for the upper floors.

Erinna, originally uploaded by jeff_robertson.

Victorian half-naked-lady statue located at formerly all-female college. There's a dirty movie in there somewhere.

Yes, the pictures I took in England finally got developed. This is the statue which, the first time I saw it (across a shadowy courtyard at 2:00 am), struck me as unnervingly.. ghostlike? I think the word is "numinous". The photo really doesn't capture that part.

Officials with the American Red Cross decided to vacate a mega relief center in DeKalb County at 5 p.m. Monday after the county CEO complained publicly about the agency's services or lack thereof.

I thought I’d discuss the anatomy of one of the more famous bugs we’ve had in Word: the “Disk is full” on save error.

In order for people to say “this sucks” they have to care enough about the thing you’ve made to spend time with it and recognize how bad it is. For things that are equally bad, but are unimportant to someone, you won’t hear the same complaint.

1. Keep that sort of thing off this blog.
2. Have a blog that consists entirely of completely safe-for-work material so I can put it on business cards and such.
3. With those eyes diverted to the other blog, I'll have greater freedom of speech here.
4. A blog on jroller.com or somewhere like that seems likely to attract an audience of people who like to read posts consisting mostly of Java code.
5. Anybody who wants to read both, can just subscribe to both.

Across all sectors the average female team leader, at 37 years old, is four years younger than her male counterpart, while female IT managers earn on average £45,869 per year — £779 more than the men do.

1. A "web page", with it's forms, buttons, etc., is represented by a POJO, or something very POJO-ish.
2. Form fields on the web page will have their values copied into like-named bean properties on the POJO. Nothing new there, this is basic Struts stuff.
3. Buttons, links, etc., being clicked by the user will result in the like-named method of the POJO being executed. Again, nothing new here.
   
4. There will be no XML config file. Everything the framework needs to know, it gets from the POJO by doing reflection or annotations or something.
5. All HTML will be generated by the framework by looking at the metadata on the POJO. That's right, there is NO template language.
6. Note that does not mean that there will be HTML in the code or the annotations; it means that there will be annotations like "@Textarea" that flag that a certain bean property is represented by a text area.
   
7. Annotations are optional, you can use this framework with older versions of Java by conforming to a naming convention for your bean properties and methods.
   
8. In other words, all you write is a bunch of plain old classes, that follow some set of naming conventions and annotations, and you produce a working web app.
9. Maybe the objects don't even have to be written in Java; maybe they are written in a language that does not need to be compiled, to facilitate on the fly hacking.
   
10. The HTML produced by the framework will be very basic and is intended to be styled completely with CSS. If you don't think CSS is powerful enough to avoid the need to customize the HTML itself, then you haven't kept up with CSS.
    
11. This is a pure web framework; it will not muddy itself by trying to deal with persistence, transactions, etc. Since the page objects are just POJO's, there should be no reason why you can't use them with EJB or Hibernate or something.

it's the same type of hype that says that one day, in the land of milk and honey, all software will be made by "component assemblers" (who presumably get paid minimum wage). I'd like to coin a term for these thingies - YAWMTI - Yet Another Way to Make Talent Irrelevant.

/*
 * StoopidDatabaseConnectionPool.java
 *
 * Created on September 8, 2005, 4:24 PM
 */
import java.util.*;
import java.sql.*;
/**
 * Really simple example of how you might use DynamicDelegator.
 *
 * @author jRobertson
 */
public class StoopidDatabaseConnectionPool {
    
    Collection pool = new HashSet();
    
    public synchronized Connection getConnection() {
        Connection con;
        if( pool.isEmpty() ) {
            
            // no connections already exist, so make one
            con = reallyConnectToDatabase();
            
        } else {
            // get one from the pool
            con = (Connection) pool.iterator().next();
            
            // remove it so no one else can have it
            pool.remove(con);
        }
        
        // wrap the connection with a proxy that will
        // put the (real) connection back into the pool
        // when the proxy is closed.
        return (Connection) new PooledConnection(con).getProxy();
        
    }
    
    
    // named class, not anonymous, because of issues using
    // reflection on local classes
    public class PooledConnection extends DynamicDelegator {
        
        public PooledConnection(Connection c) {
            super(c);
        }
        public void close() {
            pool.add(wrapped);
        }

    }
    
    private Connection reallyConnectToDatabase() {
        // not implemented for this silly example!
        // if you want to try it, implement it yourself
        
        // create a mock "Connection" that implements the
        // Connection interface in the sense of being able
        // to be assignable, but which does not actually
        // implement any of the methods (they will throw exceptions).
        // Another crazy use for InvocationChain.
        InvocationChain chain = new InvocationChain();
        chain.add(new Object() );
        chain.addInterface(Connection.class);
        return (Connection) chain.newProxyInstance();
    }
    
    public String toString() {
        return "StoopidDatabaseConnectionPool: "+pool.size();
    }

    public int size() {
        return pool.size();
    }
    
    
}

   public class MapWrapper extends DynamicDelegator {

       public MapWrapper(Object o) {
           super(o);
       }

       public Object put(Object key, Object value) {
           System.out.println("Put called!");
           return ((Map)wrapped).put(key,value);
       }
   }
 

      Map m = (Map) new MapWrapper(new HashMap()).getProxy();
      m.put("foo","bar");
      System.out.println( m.get("foo"));
 

   public class MapWrapper extends DynamicDelegator implements Runnable {

       public MapWrapper(Object o) {
           super(o);
       }

       public Object put(Object key, Object value) {
           System.out.println("Put called!");
           return ((Map)wrapped).put(key,value);
       }

       public void run() {
          System.out.println("Whoohoo!");
       }
   }
 

      Map m = (Map) new MapWrapper(new HashMap()).getProxy();
      m.put("foo","bar");
      System.out.println( m.get("foo"));
      ((Runnable)m).run();
 

/*
 * DynamicDelegator.java
 *
 * Created on January 13, 2005, 9:31 AM
 */

import java.lang.reflect.*;

/**
 * A class to make it easy to write dynamic proxies that
 * wrap existing classes. Simply write methods that have
 * the same names and signatures as the methods that you
 * want to override. All other methods will be tunnelled
 * straight through to the wrapped object. Uses reflection
 * heavily, obviously.
 * <p>
 * It is not neccessary for the wrapper class to implement the same
 * interface(s) as the wrapped object at compile time. Method name matching
 * takes place dynamically at run time.
 * <p>
 * For a simple example, a wrapper around java.util.Map might look like this:
 * <pre>
 *   public class MapWrapper extends DynamicDele {
 *
 *       public MapWrapper(Object o) {
 *           super(o);
 *       }
 *
 *       public Object put(Object key, Object value) {
 *           System.out.println("Put called!");
 *           return ((Map)wrapped).put(key,value);
 *       }
 *   }
 * </pre>
 * Another class might use MapWrapper like this:
 * <pre>
 *      Map m = (Map) new MapWrapper(new HashMap()).getProxy();
 *      m.put("foo","bar");
 *      System.out.println( m.get("foo"));
 * </pre>
 * When <code>put</code> is called, the method declared in MapWrapper
 * will be executed. When <code>get</code> is called, the method executed
 * will be the one from HashMap. It so happens that in this case, MapWrapper's
 * <code>put</code> method also calls the method on the underlying Map after
 * doing some logging output.
 * <p>
 * Here is an example that illustrates the introduction of an extra interface
 * (in this case, Runnable) that is not implemented by the wrapped class:
 *<pre>
 *   public class MapWrapper extends DynamicDelegator implements Runnable {
 *
 *       public MapWrapper(Object o) {
 *           super(o);
 *       }
 *
 *       public Object put(Object key, Object value) {
 *           System.out.println("Put called!");
 *           return ((Map)wrapped).put(key,value);
 *       }
 *
 *       public void run() {
 *          System.out.println("Whoohoo!");
 *       }
 *   }
 * </pre>
 * Obviiously the above is highly contrived.
 * The code to use it might look like this:
 * <pre>
 *      Map m = (Map) new MapWrapper(new HashMap()).getProxy();
 *      m.put("foo","bar");
 *      System.out.println( m.get("foo"));
 *      ((Runnable)m).run();
 * </pre>
 * @see java.lang.reflect.Proxy
 * @see java.lang.reflect.InvocationHandler
 * @see WrapperFactory
 * @author jRobertson
 */
public abstract class DynamicDelegator {
    
    /**
     * The inner object that is being wrapped by us.
     */
    protected Object wrapped;
    
    /**
     * If the getProxy method has been called, thisProxy
     * is a reference to the proxy object that was returned
     * by getProxy. This reference may be passed to any callbacks
     * or other methods where you would normally pass "this".
     */
    protected Object thisProxy;
        
    /** Creates a new instance of DynamicDelegator */
    public DynamicDelegator(Object wrapped) {
        this.wrapped = wrapped;
    }

    
    /**
     * Uses InvocationChain to tie this wrapper and the wrapped object
     * together as a single proxy instance. The proxy implements all
     * interfaces that are implemented by either this wrapper or by
     * the wrapped Object, as well as any interfaces returned by the
     * getAdditionalInterfaces method. Any method called on this proxy
     * will be invoked on the wrapper if such a method if found there,
     * or on the wrapped object otherwise.
     * @see InvocationChain
     */
    public Object getProxy() {
        InvocationChain chain = new InvocationChain();
        chain.add(this);
        chain.add(wrapped);
        chain.addInterfaces(getAdditionalInterfaces());
        thisProxy = chain.newProxyInstance();
        return thisProxy;
    }
    
  
    

    /**
     * Normally this returns a zero-length array. Override to specify
     * that the proxies created by this class should implement the
     * returned interface(s) in addition to any that are implemented
     * by the wrapper or the wrapped object.
     */
     protected Class[] getAdditionalInterfaces() {
         return new Class[0];
     }
 
    
}

/*
 * WrapperTest.java
 * JUnit based test
 *
 * Created on January 13, 2005, 9:43 AM
 */

import junit.framework.*;

/**
 *
 * @author jRobertson
 */
public class WrapperTest extends TestCase {
    
    public WrapperTest(String testName) {
        super(testName);
    }
    
    

    protected void setUp() throws java.lang.Exception {
    }

    protected void tearDown() throws java.lang.Exception {
    }
    
    // TODO add test methods here. The name must begin with 'test'. For example:
    // public void testHello() {}

    public void testMap() throws Exception {
        
        java.util.Map m = new java.util.HashMap();
        
        MapWrapper mw = new MapWrapper(m);
        
        java.util.Map proxyMap = (java.util.Map) mw.getProxy();
        
        proxyMap.put("a","b");
        
        assertEquals("b", proxyMap.get("a"));
        
        assertTrue(mw.putCalled);
        
    }

    public void testRunnableMap() throws Exception {
        
        java.util.Map m = new java.util.HashMap();
        
        RunnableMapWrapper mw = new RunnableMapWrapper(m);
        
        java.util.Map proxyMap = (java.util.Map) mw.getProxy();
        
        proxyMap.put("a","b");
        
        assertEquals("b", proxyMap.get("a"));
        
        assertTrue(mw.putCalled);
        
        ((Runnable)proxyMap).run();
        
        assertTrue(mw.runRan);
        
    }
    
    public void testRunnableMap2() throws Exception {
        
        java.util.Map m = new java.util.HashMap();
        
        RunnableMapWrapper2 mw = new RunnableMapWrapper2(m);
        
        java.util.Map proxyMap = (java.util.Map) mw.getProxy();
        
        proxyMap.put("a","b");
        
        assertEquals("b", proxyMap.get("a"));
        
        assertTrue(mw.putCalled);
        
        ((Runnable)proxyMap).run();
        
        assertTrue(mw.runRan);
        
    }
    
    public class MapWrapper extends DynamicDelegator {
    
        public boolean putCalled = false;

        public MapWrapper(Object o) {
            super(o);
        }


        public Object put(Object key, Object value) {
            putCalled = true;
            return ((java.util.Map)wrapped).put(key,value);
        }

    }


    public class RunnableMapWrapper extends DynamicDelegator {
    
        public boolean putCalled = false;
        public boolean runRan = false;

        public RunnableMapWrapper(Object o) {
            super(o);
        }

        protected Class[] getAdditionalInterfaces() {
            return new Class[] {
                Runnable.class
            };
        }

        public Object put(Object key, Object value) {
            putCalled = true;
            System.out.println("Put called!");
            return ((java.util.Map)wrapped).put(key,value);
        }
        
        public void run() {
            runRan = true;
        }

    }


    
    public class RunnableMapWrapper2 extends DynamicDelegator implements Runnable {
    
        public boolean putCalled = false;
        public boolean runRan = false;

        public RunnableMapWrapper2(Object o) {
            super(o);
        }

        public Object put(Object key, Object value) {
            putCalled = true;
            System.out.println("Put called!");
            return ((java.util.Map)wrapped).put(key,value);
        }
        
        public void run() {
            runRan = true;
        }

    }    
    
    
}

/*
 * InvocationChain.java
 *
 * Created on January 18, 2005, 10:46 PM
 */

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

/**
 * Uses reflection to create a chain of responsibility out of a
 * collection of otherwise unrelated classes.
 *
 * @see java.lang.Proxy
 * @see java.lang.InvocationHandler
 * @see DynamicDelegator
 *
 * @author jRobertson
 */
public class InvocationChain implements InvocationHandler {
    
    private Set interfaces = new HashSet();
    private LinkedList links = new LinkedList();
    
    /** Creates a new instance of InvocationChain */
    public InvocationChain() {
    }
    
    /** Creates a new instance of InvocationChain
     *  with one object.
     */
    public InvocationChain(Object a) {
        this();
        add(a);
    }

    /** Creates a new instance of InvocationChain
     *  with one object.
     */
    public InvocationChain(Object a, Object b) {
        this();
        add(a);
        add(b);
    }

    /**
     * Adds the specified object to the end of the chain.
     */
    public void add(Object o) {
        ChainLink link = new ChainLink(o);
        links.add(link);
        ReflectionUtils.getAllInterfaces(o.getClass(), interfaces);
    }
    
    /**
     * Manually add this interface to this list of interfaces
     * that will be implemented by this chain.
     */
    public void addInterface(Class c) {
        interfaces.add(c);
    }
    
    /**
     * Manually add these interfaces to this list of interfaces
     * that will be implemented by this chain.
     */
    public void addInterfaces(Class[] c) {
        interfaces.addAll(Arrays.asList(c));
    }    
    
    /**
     * This method implements the InvocationHandler interface. The chain
     * of responsibility will be searched until a method of the required
     * name and argument types is found, and that method will then be
     * invoked. The search stops after finding the first occurrence of
     * a method in the chain, so the order in which the objects were
     * added is important.
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
        // search the objects in the chain, one by one
        for(Iterator i=links.iterator(); i.hasNext();) {
            ChainLink link = (ChainLink) i.next();
            
            // if the class implements the interface that 
            // declared this method, run it. we do this because
            // I've seen cases where methods declared by a class's
            // distant ancestors don't show up when you enumerate
            // it's methods. specifically, the Connection objects
            // returned from Oracle's database driver are like this.
            if( method.getDeclaringClass().isAssignableFrom( link.getObject().getClass() ) ) {
                return method.invoke(link.getObject(), args);
            }
            
            // if the class has a method that has the same
            // name and type as this method, find that
            // method and run it instead
            Method match = link.matchMethod(method);
            if( match != null) {
                return match.invoke(link.getObject(), args);
            }
            
        }

        // ok, the fast way of just looking stuff up in a hashmap
        // failed... now try the slow way that involves catching
        // exceptions. not sure if it is really possible to get
        // here, but you never can tell with reflection
        for(Iterator i=links.iterator(); i.hasNext();) {
            ChainLink link = (ChainLink) i.next();
            
            try {
                return method.invoke(link.getObject(), args);
            } catch (IllegalAccessException e) {
                // nothing
            } catch (IllegalArgumentException e) {
                // nothing
            }
        }
        
        throw new NoSuchMethodException("couldn't find metho in my chain of respsonsibility: "+method);
    }

    /**
     * Returns the set of all interfaces implemented by
     * any objects in the chain.
     */
    public Class[] getInterfaces() {
        Class[] intArray = new Class[interfaces.size()];
        return (Class[]) interfaces.toArray(intArray);
    }
    
    /**
     * Creates a proxy that implements all interfaces that are
     * implemented by any object in the chain, and with this
     * InvocationChain as the invocation handler.
     */
    public Object newProxyInstance() {
        return Proxy.newProxyInstance(getClass().getClassLoader(), getInterfaces(), this);             
    }
    
    /**
     * Inner class for each delegate in the chain.
     */
    private static class ChainLink {
        private Map methodMap = new java.util.HashMap();
        private Object object;

        ChainLink(Object o) {
            object = o;
            Method[] methods = o.getClass().getMethods();
            for(int i=0; i<methods.length;i++) {
                Method method = methods[i];
                
                // do not count methods that we can't access
                if( Modifier.isPublic(method.getModifiers()) 
                    &&
                    Modifier.isPublic(method.getDeclaringClass().getModifiers())
                ) {
                    methodMap.put( new MethodSig(method), method);
                }
            }            
        }
        
        Method matchMethod(Method m) {
            return (Method)methodMap.get( new MethodSig(m));
        }
        
        Object getObject(){ return object; }
        
        
    }
    
   
    
}

import junit.framework.*;
/*
 * InvocationChainTest.java
 * JUnit based test
 *
 * Created on September 1, 2005, 12:02 PM
 */

/**
 *
 * @author jRobertson
 */
public class InvocationChainTest extends TestCase {
    
    public InvocationChainTest(String testName) {
        super(testName);
    }
    

    public static interface Animal {
        String speak();
    }
    
    public static interface Vehicle {
        int topSpeed();
    }       
   
    public static class Dog implements Animal {
        public String speak() {
            return "woof!";
        }
    }

    public static class Sled implements Vehicle {
        public int topSpeed() {
            return 5;
        }
    }
    
    public void testChain() {
        
        InvocationChain chain = new InvocationChain(new Dog(), new Sled());
        
        Object dogSled = chain.newProxyInstance();
        
        assertEquals( "woof!", ((Animal) dogSled).speak()  );

        assertEquals( 5, ((Vehicle) dogSled).topSpeed()  );
        
    }
    
}

/*
 * ReflectionUtils.java
 *
 * Created on January 18, 2005, 8:07 PM
 */

/**
 * Utility methods for reflection, classes, interfaces, etc.
 * @author jRobertson
 */
public class ReflectionUtils {
    
    /**
     * Recursively walks the graph of all superclasses and interfaces
     * that are related to the passed-in class, and adds all the Class
     * objects representing all the interfaces that are found to the
     * passed-in Set.
     */
    public static java.util.Set getAllInterfaces(Class c) {
        java.util.Set s = new java.util.HashSet();
        getAllInterfaces(c, s);
        return s;
    }
    
    /**
     * Recursively walks the graph of all superclasses and interfaces
     * that are related to the passed-in class, and adds all the Class
     * objects representing all the interfaces that are found to the
     * passed-in Set.
     */
    public static void getAllInterfaces(Class c, java.util.Set col) {
        
        if(c == null) {
            return;
        }
        
        Class[] ifaces = c.getInterfaces();
        
        for(int i=0; i< ifaces.length; i++) {
            col.add(ifaces[i]);
            getAllInterfaces(ifaces[i], col);
        }
        
        getAllInterfaces(c.getSuperclass(), col);
        
    }
    
    
}

Bayou La Batre was an impoverished coastal town in Alabama before Katrina swept through its mobile homes and one-story houses. Jim Zarroli went on patrol with a FEMA official and reports and how residents are coping with what's left and what's lost.

/*
 * MyInvocationHandler.java
 *
 * Created on September 7, 2005, 1:35 PM
 */
import java.lang.reflect.*;
import java.util.*;
/**
 * Test code for my blog postings about InvocationHandlers.
 *
 * @author jRobertson
 */

public class MyInvocationHandler implements InvocationHandler {

   /**
    * The interface for the class that we are proxying/decorating/delegating-to.
    */
   public static interface SomeInterface {
       int foo(int x);
       void bar(String s);
       boolean baz();
       void quux();
   }
   
   
   /**
    * An implementation of this interface.
    */
   public static class SomeImpl implements SomeInterface {
       public int foo(int x) {
           System.out.println("SomeImpl.foo");
           return x+1;
       }
       public void bar(String s) {
           System.out.println("SomeImpl.bar");
       }
       public boolean baz() {
           System.out.println("SomeImpl.baz");
           return true;
       }
       public void quux() {
           System.out.println("SomeImpl.quux");
       }   
   }
    
    
    
    private Object realObject;
    
    private Map methodsMap = new HashMap();

    private void addMethod(Method m) {
       methodsMap.put( new MethodSig(m), m);
    }

    public MyInvocationHandler(Object realObject) {
        this.realObject = realObject;
    
        Method[] methods = getClass().getMethods();
        for(int i =0; i<methods.length; i++) {
           addMethod( methods[i]);
        }
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable   {
        Method myMethod = (Method) methodsMap.get( new MethodSig(method));

        if( myMethod != null ) {
            // if it's in the map, run the one from the map
            return myMethod.invoke(this,args);
        } else {
            // otherwise just run the method on the original object
            return method.invoke(realObject,args);
        }
  }

   /**
    * Replacement method that overrides the matching foo() method
    */
   public int foo(int x) {
       System.out.println("MyInvocationHandler.foo");
       return ((SomeInterface) realObject).foo(x);
   }

   /**
    * Replacement method that overrides the matching bar() method
    */
   public void bar(String s) {
      // do nothing! hahaha
   }

   /**
    * Replacement method that overrides the matching baz() method
    */
   public boolean baz() {
           throw new RuntimeException("you can't call baz()!");
   }
   
   
   // notice that we have no replacement method for quux()
   
   
   /**
    * Main method to serve as a basic test.
    */
   public static void main(String args[]) throws Throwable {
       
       SomeInterface si = (SomeInterface)
              Proxy.newProxyInstance(MyInvocationHandler.class.getClassLoader(), new Class[]{SomeInterface.class}, new MyInvocationHandler(new SomeImpl()));
       
       // should print:
       //   MyInvocationHandler.foo
       //   SomeImpl.foo
       si.foo(1);
       
       // should print NOTHING, since the proxy should suppress the call to the object
       si.bar("test");
       
       // should print "SomeImpl.quux" because we don't declare a replacement method
       si.quux();
       
       // should throw!
       try {
           si.baz();
       } catch (Throwable t) {
           System.out.println(t);
       }
       
   }
   
}

/*
 * MethodSig.java
 *
 * Created on September 7, 2005, 1:36 PM
 */

import java.lang.reflect.Method;

/**
 * Hash key for a map of methods based on method name and parameters.
 */
public class MethodSig extends HashKey {
    public MethodSig(Method m) {
        super( m.getName(),
                java.util.Arrays.asList( m.getParameterTypes()) );

    }
}    

/*
 * HashKey.java
 *
 * Created on February 8, 2005, 9:54 AM
 */

import java.util.*;

/**
 * A convenience class for easily making hashmap
 * keys that involve multiple objects. Essentially
 * just a read-only collection of Objects, except for
 * the 9 overloaded constructors that allow you to
 * write code like this:
 * <pre>
 * 
 *    map.put( new HashKey("foo","bar"), someValue);
 *
 *    Object v = map.get( new HashKey("foo","bar"));
 *
 * </pre>
 *
 * Can be useful as a base class for local hash key classes:
 *
 * <pre>
 *
 *    public class MyHashKey extends HashKey {
 *      public MyHashKey(SomeClass thing) {
 *          super( thing.getFoo(), thing.getBar());
 *      }
 *    }
 *  
 * </pre> 
 *
 * @author jRobertson
 */
public class HashKey extends AbstractCollection implements Collection, java.io.Serializable {
  
    private Collection keys;
    
    /** Creates a new instance of HashKey */
    public HashKey(Object key1) {
        this( new Object[]{ key1 });
    }

    /** Creates a new instance of HashKey */
    public HashKey(Object key1, Object key2) {
        this( new Object[]{ key1, key2});
    }

    /** Creates a new instance of HashKey */
    public HashKey(Object key1, Object key2, Object key3) {
        this( new Object[]{ key1,key2,key3});
    }
    
    /** Creates a new instance of HashKey */
    public HashKey(Object key1, Object key2, Object key3, Object key4) {
        this( new Object[]{ key1,key2,key3,key4});
    }

    /** Creates a new instance of HashKey */
    public HashKey(Object key1, Object key2, Object key3, Object key4, Object key5) {
        this( new Object[]{ key1,key2,key3,key4,key5});
    }
    
    /** Creates a new instance of HashKey */
    public HashKey(Object key1, Object key2, Object key3, Object key4, Object key5, Object key6) {
        this( new Object[]{ key1,key2,key3,key4,key5,key6});
    }
    
    /** Creates a new instance of HashKey */
    public HashKey(Object key1, Object key2, Object key3, Object key4, Object key5, Object key6, Object key7) {
        this( new Object[]{ key1,key2,key3,key4,key5,key6,key7});
    }

    /** Creates a new instance of HashKey */
    public HashKey(Object key1, Object key2, Object key3, Object key4, Object key5, Object key6, Object key7, Object key8) {
        this( new Object[]{ key1,key2,key3,key4,key5,key6,key7,key8});
    }

    /** Creates a new instance of HashKey */
    public HashKey(Object key1, Object key2, Object key3, Object key4, Object key5, Object key6, Object key7, Object key8, Object key9) {
        this( new Object[]{ key1,key2,key3,key4,key5,key6,key7,key8,key9});
    }
    

    /** Creates a new instance of HashKey */
    public HashKey(Object[] keys) {
        this( Arrays.asList(keys));
    }
    
    
    /** Creates a new instance of HashKey */
    public HashKey(Collection keysToAdd) {
        keys = keysToAdd;
    }

    public boolean equals(Object obj) {

        if( !(obj instanceof HashKey) )
            return false;
        
        HashKey that = (HashKey) obj;
        
        return keys.equals( that.keys);

    }

    public String toString() {
        return keys.toString();
    }

    public int hashCode() {
        return keys.hashCode();
    }

    public int size() {
        return keys.size();
    }

    public Iterator iterator() {
        return keys.iterator();
    }
   
    
}

class MyInvocationHandler implements InvocationHandler {
 
    public MyInvocationHandler(Object realObject) {
        this.realObject = realObject;
    }

    private Object realObject;

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable   {
        // log it
        log.debug(m);

        // now run it
        m.invoke( realObject, args);
    }
}

    private Object realObject;

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable   {
        if( m.getName().equals( "foo" )) {
           // .. insert any special logic for foo method here ..

           // followed by actually running the method
           m.invoke( realObject, args);
        } else if (m.getName().equals( "bar" )) {
           // swallow the call to bar() and don't pass it on!
        } else if (m.getName().equals( "baz" )) {
           throw new SomeException("you can't call baz()!");
        } else {
           // any other method, just call it straight through
           m.invoke( realObject, args);
        }

    }

  private Map handlersMap = new HashMap();

  public MyInvocationHandler(Object realObject) {
    this.realObject = realObject;

    handlersMap.put("foo", new InvocationHandler() {
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable    {
        // special code for foo()
      }
    );

    // add mappings for bar(), baz(), etc..

  }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable   {
        InvocationHandler h = (InvocationHandler) handlersMap.get(method.getName());

        if( h != null ) {
            h.invoke(proxy,method,args);
        } else {
            method.invoke(realObject,args);
        }
  }

    private Map methodsMap = new HashMap();

    methodsMap.put( "foo", getClass().getMethod("foo", new Class[]{ int.class });
    methodsMap.put( "bar", getClass().getMethod("bar", new Class[]{ String.class });
    methodsMap.put( "bar", getClass().getMethod("baz", new Class[]{ });

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable   {
        Method myMethod = (Method) handlersMap.get(method.getName());

        if( myMethod != null ) {
            // if it's in the map, run the one from the map
            myMethod.invoke(this,args);
        } else {
            // otherwise just run the method on the original object
            method.invoke(realObject,args);
        }
  }

   public int foo(int x) {
      // .. any custom stuff goes here ...
      return (SomeInterface) realObject.foo(x);
   }

   public void bar(String s) {
      // do nothing! hahaha
   }

   public boolean baz() {
           throw new SomeException("you can't call baz()!");
   }

class MethodSig extends HashKey {
        public MethodSig(Method m) {
            super( m.getName(),
                    java.util.Arrays.asList( m.getParameterTypes()) );
            
        }
    }    

public class HashKey extends AbstractCollection implements Collection, java.io.Serializable {
  
    private Collection keys;
    
    /** Creates a new instance of HashKey */
    public HashKey(Object key1) {
        this( new Object[]{ key1 });
    }

    /** Creates a new instance of HashKey */
    public HashKey(Object key1, Object key2) {
        this( new Object[]{ key1, key2});
    }

    /** Creates a new instance of HashKey */
    public HashKey(Object key1, Object key2, Object key3) {
        this( new Object[]{ key1,key2,key3});
    }

    // repeat constructors for as many different objects as you might want..

    /** Creates a new instance of HashKey */
    public HashKey(Object[] keys) {
        this( Arrays.asList(keys));
    }
    
    
    /** Creates a new instance of HashKey */
    public HashKey(Collection keysToAdd) {
        keys = keysToAdd;
    }

    public boolean equals(Object obj) {

        if( !(obj instanceof HashKey) )
            return false;
        
        HashKey that = (HashKey) obj;
        
        return keys.equals( that.keys);

    }

    public String toString() {
        return keys.toString();
    }

    public int hashCode() {
        return keys.hashCode();
    }

    public int size() {
        return keys.size();
    }

    public Iterator iterator() {
        return keys.iterator();
    }
    
}

public class MyInvocationHandler implements InvocationHandler {
    private Map methodsMap = new HashMap();

    private void addMethod(Method m) {
       methodsMap.put( new MethodSig(m), m);
    }

    public MyInvocationHandler(Object realObject) {
        this.realObject = realObject;
    
        addMethod( getClass().getMethod("foo", new Class[]{ int.class });
        addMethod( getClass().getMethod("bar", new Class[]{ String.class });
        addMethod( getClass().getMethod("baz", new Class[]{ });
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable   {
        Method myMethod = (Method) handlersMap.get( new MethodSig(method) );

        if( myMethod != null ) {
            // if it's in the map, run the one from the map
            myMethod.invoke(this,args);
        } else {
            // otherwise just run the method on the original object
            method.invoke(realObject,args);
        }
  }

   public int foo(int x) {
      // .. any custom stuff goes here ...
      return (SomeInterface) realObject.foo(x);
   }

   public void bar(String s) {
      // do nothing! hahaha
   }

   public boolean baz() {
           throw new SomeException("you can't call baz()!");
   }
}

public class MyInvocationHandler implements InvocationHandler {
    private Map methodsMap = new HashMap();

    private void addMethod(Method m) {
       methodsMap.put( new MethodSig(m), m);
    }

    public MyInvocationHandler(Object realObject) {
        this.realObject = realObject;
    
        Method[] methods = getClass().getMethods();
        for(i =0; i<methods.length; i++) {
           addMethod( methods[i]);
        }
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable   {
        Method myMethod = (Method) handlersMap.get( new MethodSig(method));

        if( myMethod != null ) {
            // if it's in the map, run the one from the map
            myMethod.invoke(this,args);
        } else {
            // otherwise just run the method on the original object
            method.invoke(realObject,args);
        }
  }

   public int foo(int x) {
      // .. any custom stuff goes here ...
      return (SomeInterface) realObject.foo(x);
   }

   public void bar(String s) {
      // do nothing! hahaha
   }

   public boolean baz() {
           throw new SomeException("you can't call baz()!");
   }
}

# In Netscape Navigator 1.0 through 4.0, the history.db file was just a
# Berkeley DBM file. You could trivially bind to it from Perl, and
# pull out the URLs and last-access time. In Mozilla, this has been
# replaced with a "Mork" database for which no tools exist.
#
# Let me make it clear that McCusker is a complete barking lunatic.
# This is just about the stupidest file format I've ever seen.

AL 188 Closed Mobile PADGET SWITCH ROAD TO ALABAMA PORT WATER AND DEBRIS OVER THE ROAD.

The Geograph British Isles project aims to collect a geographically representative photograph for every square kilometre of the British Isles and you can be part of it.

Now you are in a maze of twisty little passages, all alike. A skeleton, probably the remains of a luckless consumer, lies here. Beside the skeleton is a rusty SKARPT high-quality steel knife with hard plastic handle and a shopping cart. Search the body. Take the IKEA GIFT CARD (still has $43 on it). Take and eat the SWEDISH FISH for sustenance. Now go:

S, E, D, D, E, SW, W, SW, D, W, U, S.

it must be fate but it should be a crime
my heart is yours but yours is not mine

i lost my mind and i'd give my soul
for a chance to have you once to hold

i know you love another man
and you are going to take his hand

sing loud sweet stereo
i need a little music to get me through the sad times

sing loud sweet stereo
i need a little music to get me through the bad times

hold me close just for one time
i want this memory to last lifetime

you can't understand what i feel for you
but that's ok you don't need to

i can live with separateness
as long as you find happiness

sing loud sweet stereo
i need a little music to get me through the sad times

sing loud sweet stereo
just a little music to get me through the bad times

and let the music that you play
help me fill the lonely days
with a little bit of love and light
a little bit of love and light

If our leaders are really planning for panic, in the technical sense, then they are at best wasting resources on a future that is unlikely to happen. At worst, they may be doing our enemies' work for them - while people are amazing under pressure, it cannot help to have predictions of panic drummed into them by supposed experts.

Lookin' for chicks at Home Depot.
Lookin' for chicks among the boat people.

(Lookin' for Chicks!)
(Lookin' for Chicks!)

Lookin' for chicks in the elevator.
Lookin' for chicks in Decatur.

(Lookin' for Chicks!)
(Lookin' for Chicks!)

Lookin' for chicks who give second chances.
Lookin' for chicks who give lap dances.

(Lookin' for Chicks!)
(Lookin' for Chicks!)

Annie don't you worry.
Annie don't you cry.
You know that I will always
be you your alibi.

I'll tell the judge and the jury
that you were layin' in my arms.
I'll them 'em that you were with me
the night your old man come to harm.

Annie what's the matter?
Did I offend your pride?
Can't you say that you love me
just to save your hide?

Annie I don't believe it.
Annie how can this be?
You're gonna point your little finger
and make a scapegoat out of me.

The judge done banged his gavel,
and soon I'm gonna fry.
But you know that I still love you.
And I'll still be your alibi.

I'll tell old Saint Peter
that you were layin' in my arms.
I'll tell 'im that you were with me
when your old man come to harm.

My Adrienne,
show me your face;
so out of place.

My Adrienne,
come to my room;
I'll seal your doom.

My Adrienne,
take off your clothes;
put on my robe.

My Adrienne,
drink from this cup;
it will wake you up.

My Adrienne,
why do you scream?
I'll set you free.

My Adrienne,
oh how you cry.
It's time to die.

In this paper we describe an issue that was raised in 2001 under the name of Cross-Site Request Forgeries (CSRF) [1]. It seems, though, that it has been neglected by the software development and Web Application Security community