Dear [...],

First of all, excuse me for not noticing your message until now during this
long vacation weekend.

The algorithm proceeds as follows:

1.  Pick an extreme rightmost point.  P_0.  If there are two or more, pick
the top one.

2.  If any other point has the same coordinates as the extreme point,
discard it.  Sort all other points (removing duplicates) by using the
slope of the line between P_0 and the point as the key.  Sort from
lowest slope to highest slope, rembering that the every negative number is
less than every positive number.
If a point is directly below P_0 then the slope is infinity, which is the
largest possible slope.

If there are multiple points for which the key is the same,
discard all but one that is farthest from P_0.

(If you sort the other way, the other parts of the algorithm must be
modified appropriately.)

Let x_1, .... x_m be the points in the sorted order.  Let x_{m+1} = P_0.

3.  Create a stack, and initialize it by pushing P_0.

4.  The vertex search has m+1 phases.  During phase t, point x_t is
considered for the first time:

For each t from 1 to m+1:
{ // begin phase t
	// begin loop
	If the stack has only one element, (which will be P_0), exit loop.
	Else
		{ // begin Outer Else branch
		 Let T be the the top item of the stack and U the second
		 from the top item;

		 If the arrow from T to x_t "turns left" with respect
		 to the arrow from U to T, then exit the loop.
		 // test that condition by evaluating a 2x2 determinant
		 Else, pop and discard T, and do not exit the loop.
		} // end Outer Else branch
	// end loop
Push x_t onto the stack.
} // end phase t

When you are done, P_0 will be in the stack twice, at the bottom and
at the top.  The stack will be the list of vertices of the convex hull
in counter-clockise order.

5.  Compute the area.

I advise you to take a piece of graph paper, put down a few points,
and walk through the algorithm by hand before trying to code it.