Attacks on consumer devices with web interfaces, e.g., NAS, by exploiting not-necessarily http protocol, e.g., FTP. As an example, an attacker loads crafted contents via FTP to victims’s web based control panel. When the admin visits the admin web app, it’s owned by the attacker.

Output:
Never use new Boolean.
new Boolean is an Object and it’s always true.
I told you. Object is true!
Also, stay away from new Array. Use [].
See. new Array is confusing.
undefinedundefinedundefinedundefinedundefinedundefinedundefinedundefinedundefinedundefined
1020
[elem1, elem2, ...] is obvious.
10
1020

But,
“3″-1 : 2
“4″ / 2 : 2
“2″ * 2 : 4
“2″ * “2″: 4

A hash scheme that does not affects the entire hash table when a node is inserted or deleted. Machines are assigned to the circular nodes, and if a machine crashes, the keys in the crashed machine are moved to the following node in the circle. This is becoming really popular due to no SQL movements.

Used by distributed hash table (This is basically consistent hashing + node lookup algorithm) or amazon dynamo.

Pairewise periodic comm. based protocol to spread information which resembles the way how gossip spreads among ppl. This protocol assumes a faulty network and decentralized. Epidemic algorithms are the ones that adopt gossip protocol.

Simple algorithm w/ cute name.

A tree where a parent contains hash of it’s children. Likewise, root has hash of all nodes. Useful for contents comparison without downloading entire tree or files. Also useful for file synchronization(e.g., Amazon Dynamo); detect missing files easily and sync.

Instead of just picking the middle, guess the position where the target value appears, and compares the value in the position with the target. This obtains O(loglogN).

이런 term의 겹침을 계산하는 방법 중 하나는 locality sensitive hashiing입니다. 위키의 식 중 하나를 인용해서 설명하면 가 localitiy sensitive hashing입니다. 즉, 어떤 해싱 함수를 써서 a와 b를 변환한다음 그 값이 같을 확률은 a와 b의 유사도와 같다라는 것입니다.

여기까지가 introduction이고 본문은 http://knol.google.com/k/simple-simhashing에 있습니다. 혹은 Soumen Chakrabarti, Mining the web, Morgan Kaufmann에도 설명되어있습니다. (좋은 책입니다.)

knol의 글에서는 여러번반복해서 을 구한다고 되어있는데, Mining the web에서는 m개의 hash function을 찾은다음 그 중에서 k회 가 성립하면 으로 계산하고 있습니다.

import java.util.Observable;
import java.util.Observer;

public class Framework extends Observable {

  public void SendMessage(String msg) {
    setChanged();
    try {
      notifyObservers(msg);
    } catch (RuntimeException re) {
      throw new RuntimeException("Something bad happend.");
    }
  }

  public static void main(String[] args) {
    Framework f = new Framework();
    f.addObserver(new Observer() {
      @Override
      public void update(Observable o, Object arg) {
        System.out.println("I am fine: " + arg.toString());
      }
    });
    f.SendMessage("hello world");
  }
}

This is pretty common pattern. Right? You create a list of several instances and iterate over them to do something. Actually, that’s the beautiful pattern commonly used.

But, the code actually has a pitfall. Look at the error handling part. Can you identify it?

try {
  notifyObservers(msg);
} catch(RuntimeException re) {
  throw new RuntimeException("Something bad happend.");
}

At first glance, this looks fine. It’s trying to tell something to the user. It’s not even swallowing the exception. But that’s not all for the framework developer. What happens if I add an innocent observer but got some error?

  public static void main(String[] args) {
    Framework f = new Framework();
    f.addObserver(new Observer() {
      @Override
      public void update(Observable o, Object arg) {
        System.out.println("I am fine: " + arg.toString());
      }
    });
    f.addObserver(new Observer() {
      @Override
      public void update(Observable o, Object arg) {
        throw new RuntimeException("I got an error: " + arg.toString());
      }
    });
    f.SendMessage("hello world");
  }

Now the code spits out this:

Exception in thread “main” java.lang.RuntimeException: Something bad happend.
at Framework.SendMessage(Framework.java:11)
at Framework.main(Framework.java:29)

Seriously, that’s all I get. If this happens, I’m left with no clue but something went wrong.

Please do not swallow not just your exception but also your stack trace. How can I believe that all other observers are fine but it’s just my fault without any proof?

Keep the stack trace:

try {
    notifyObservers(msg);
} catch (RuntimeException re) {
    throw new RuntimeException("Something bad happend.", re);
}

Now I get this awesome trace:

Exception in thread “main” java.lang.RuntimeException: Something bad happend.
at Framework.SendMessage(Framework.java:11)
at Framework.main(Framework.java:29)
Caused by: java.lang.RuntimeException: I got an error: hello world
at Framework$2.update(Framework.java:26)
at java.util.Observable.notifyObservers(Unknown Source)
at Framework.SendMessage(Framework.java:9)
… 1 more