I couldn’t actually find a C++ version of the soundex algorithm (all the ones I found were C code with a .cpp extension), so I threw one together.
Here it is if anyone is interested.

static char     lookup[] = {
‘0′,    /* A */
‘1′,    /* B */
‘2′,    /* C */
‘3′,    /* D */
‘0′,    /* E */
‘1′,    /* F */
‘2′,    /* G */
‘0′,    /* H */
‘0′,    /* I */
‘2′,    /* J */
‘2′,    /* K */
‘4′,    /* L */
‘5′,    /* M */
‘5′,    /* N */
‘0′,    /* O */
‘1′,    /* P */
‘0′,    /* Q */
‘6′,    /* R */
‘2′,    /* S */
‘3′,    /* T */
‘0′,    /* U */
‘1′,    /* V */
‘0′,    /* W */
‘2′,    /* X */
‘0′,    /* Y */
‘2′,    /* Z */
};

std::string computeSoundex(const std::string &input, const int resultLength){

//keep the first character intact
std::string result = input.substr(0,1);

//compute value for each character thereafter
for(int i=1;i<input.length(); i++){

//skip non-alpha characters
if(!isalpha(input[i])){
continue;
}
//uppercase the input value
const char lookupInput = islower(input[i]) ? toupper(input[i]) : input[i];
//lookup it’s value
const char *lookupVal = &lookup[lookupInput-'A'];

//make sure this isn’t a dupe value
if(result.find(lookupVal, 0) != 0 ){
result.append(lookupVal);
}
}

//make sure we could actually encode something
if(result.length() >= resultLength){
return result.substr(0,resultLength-1);

#include<stdio.h>
#include<conio.h>
#include<graphics.h>
#include<math.h>

void swap(int &x,int &y)
{
int k=x;
x=y;
y=k;
}

void main()
{
int gd=DETECT,gm=DETECT,x1,x2,y1,y2,dx,dy,p,k;
float m=0;

clrscr();

printf(”Enter the sarting point x1 & y1n”);
scanf(”%d%d”,&x1,&y1);

printf(”Enter the end point x2 & y2n”);
scanf(”%d%d”,&x2,&y2);

dx=abs(x2-x1);
dy=abs(y2-y1);
m=(float)(y2-y1)/(x2-x1);

initgraph(&gd,&gm,”");
cleardevice();

if(fabs(m)>1)
{
swap(x1,y1);
swap(x2,y2);
swap(dx,dy);
}

if((x1>x2))
{
x1=x2;
y1=y2;
}
p=2*dy-dx;
for(k=0;k<abs(dx);k++)
{
if(p<0)
{
p=p+2*dy;
}
else
{
if(m<0) y1–;
else y1++;
p=p+(2*dy)-(2*dx);
}
if(fabs(m)<=1)putpixel(x1++,y1,15);
else putpixel(y1,x1++,15);
}

getch();
}

Quote: http://cslibrary.stanford.edu/110/BinaryTrees.html

1. Build123() Solution (C/C++)

// call newNode() three times
struct node* build123a() {
  struct node* root = newNode(2);
  struct node* lChild = newNode(1);
  struct node* rChild = newNode(3);

  root->left = lChild;
  root->right= rChild;

  return(root);
}

// call newNode() three times, and use only one local variable
struct node* build123b() {
  struct node* root = newNode(2);
  root->left = newNode(1);
  root->right = newNode(3);

  return(root);
}
 

/*
 Build 123 by calling insert() three times.
 Note that the '2' must be inserted first.
*/
struct node* build123c() {
  struct node* root = NULL;
  root = insert(root, 2);
  root = insert(root, 1);
  root = insert(root, 3);
  return(root);
}
 

2. size() Solution (C/C++)

/*
 Compute the number of nodes in a tree.
*/
int size(struct node* node) {
  if (node==NULL) {
    return(0);
  } else {
    return(size(node->left) + 1 + size(node->right));
  }
}
 

3. maxDepth() Solution (C/C++)

/*
 Compute the "maxDepth" of a tree -- the number of nodes along
 the longest path from the root node down to the farthest leaf node.
*/
int maxDepth(struct node* node) {
  if (node==NULL) {
    return(0);
  }
  else {
    // compute the depth of each subtree
    int lDepth = maxDepth(node->left);
    int rDepth = maxDepth(node->right);

    // use the larger one
    if (lDepth > rDepth) return(lDepth+1);
    else return(rDepth+1);
  }
}
 

4. minValue() Solution (C/C++)

/*
 Given a non-empty binary search tree,
 return the minimum data value found in that tree.
 Note that the entire tree does not need to be searched.
*/
int minValue(struct node* node) {
  struct node* current = node;

  // loop down to find the leftmost leaf
  while (current->left != NULL) {
    current = current->left;
  }

  return(current->data);
}
 

5. printTree() Solution (C/C++)

/*
 Given a binary search tree, print out
 its data elements in increasing
 sorted order.
*/
void printTree(struct node* node) {
  if (node == NULL) return;

  printTree(node->left);
  printf("%d ", node->data);
  printTree(node->right);
}
 

6. printPostorder() Solution (C/C++)

/*
 Given a binary tree, print its
 nodes according to the "bottom-up"
 postorder traversal.
*/
void printPostorder(struct node* node) {
  if (node == NULL) return;

  // first recur on both subtrees
  printTree(node->left);
  printTree(node->right);

  // then deal with the node
  printf("%d ", node->data);
}
 

7. hasPathSum() Solution (C/C++)

/*
 Given a tree and a sum, return true if there is a path from the root
 down to a leaf, such that adding up all the values along the path
 equals the given sum.

 Strategy: subtract the node value from the sum when recurring down,
 and check to see if the sum is 0 when you run out of tree.
*/
int hasPathSum(struct node* node, int sum) {
  // return true if we run out of tree and sum==0
  if (node == NULL) {
    return(sum == 0);
  }
  else {
  // otherwise check both subtrees
    int subSum = sum - node->data; //subSum seems not necessary
    return(hasPathSum(node->left, subSum) ||
           hasPathSum(node->right, subSum));
  }
}

8. printPaths() Solution (C/C++)

/*
 Given a binary tree, print out all of its root-to-leaf
 paths, one per line. Uses a recursive helper to do the work.
*/
void printPaths(struct node* node) {
  int path[1000];

  printPathsRecur(node, path, 0);
}

/*
 Recursive helper function -- given a node, and an array containing
 the path from the root node up to but not including this node,
 print out all the root-leaf paths.
*/
void printPathsRecur(struct node* node, int path[], int pathLen) {
  if (node==NULL) return;

  // append this node to the path array
  path[pathLen] = node->data;
  pathLen++;

  // it's a leaf, so print the path that led to here
  if (node->left==NULL && node->right==NULL) {
    printArray(path, pathLen);
  }
  else {
  // otherwise try both subtrees
    printPathsRecur(node->left, path, pathLen);
    printPathsRecur(node->right, path, pathLen);
  }
}

// Utility that prints out an array on a line.
void printArray(int ints[], int len) {
  int i;
  for (i=0; i<len; i++) {
    printf("%d ", ints[i]);
  }
  printf("\n");
}
 

9. mirror() Solution (C/C++)

/*
 Change a tree so that the roles of the
 left and right pointers are swapped at every node.

 So the tree...
       4
      / \
     2   5
    / \
   1   3

 is changed to...
       4
      / \
     5   2
        / \
       3   1
*/
void mirror(struct node* node) {
  if (node==NULL) {
    return;
  }
  else {
    struct node* temp;

    // do the subtrees
    mirror(node->left);
    mirror(node->right);

    // swap the pointers in this node

         //The priority of  recursion procedure is not necessary 
    temp = node->left;
    node->left = node->right;
    node->right = temp;
  }
}
 

10. doubleTree() Solution (C/C++)

/*
 For each node in a binary search tree,
 create a new duplicate node, and insert
 the duplicate as the left child of the original node.
 The resulting tree should still be a binary search tree.

 So the tree...
    2
   / \
  1   3

 Is changed to...
       2
      / \
     2   3
    /   /
   1   3
  /
 1

*/
void doubleTree(struct node* node) {
  struct node* oldLeft;

  if (node==NULL) return;

  // do the subtrees
  doubleTree(node->left);
  doubleTree(node->right);

  // duplicate this node to its left
  oldLeft = node->left;
  node->left = newNode(node->data);
  node->left->left = oldLeft;
} 
 
void doubleTree(struct node* node){
    if(node==NULL)
    return;

    else{
    struct node* duplicate=NewMode(node->data);

    doubleTree(node->left);
    doubleTree(node->right);

    duplicate->left=node->left;
    node->left=duplicate;

       }
}

11. sameTree() Solution (C/C++)

/*
 Given two trees, return true if they are
 structurally identical.
*/
int sameTree(struct node* a, struct node* b) {
  // 1. both empty -> true
  if (a==NULL && b==NULL) return(true);

  // 2. both non-empty -> compare them
  else if (a!=NULL && b!=NULL) {
    return(
      a->data == b->data &&
      sameTree(a->left, b->left) &&
      sameTree(a->right, b->right)
    );
  }
  // 3. one empty, one not -> false
  else return(false);
}
 
 

12. countTrees() Solution (C/C++)

/*
 For the key values 1...numKeys, how many structurally unique
 binary search trees are possible that store those keys.

 Strategy: consider that each value could be the root.
 Recursively find the size of the left and right subtrees.
*/
int countTrees(int numKeys) {

  if (numKeys <=1) {
    return(1);
  }
  else {
    // there will be one value at the root, with whatever remains
    // on the left and right each forming their own subtrees.
    // Iterate through all the values that could be the root...
    int sum = 0;
    int left, right, root;

    for (root=1; root<=numKeys; root++) {
      left = countTrees(root - 1);
      right = countTrees(numKeys - root);

      // number of possible trees with this root == left*right
      sum += left*right;
    }

    return(sum);
  }
}
 
 

13. isBST1() Solution (C/C++)

/*
 Returns true if a binary tree is a binary search tree.
*/
int isBST(struct node* node) {
  if (node==NULL) return(true);

  // false if the max of the left is > than us

  // (bug -- an earlier version had min/max backwards here)
  if (node->left!=NULL && maxValue(node->left) > node->data)
    return(false);

  // false if the min of the right is <= than us
  if (node->right!=NULL && minValue(node->right) <= node->data)
    return(false);

  // false if, recursively, the left or right is not a BST
  if (!isBST(node->left) || !isBST(node->right))
    return(false);

  // passing all that, it's a BST
  return(true);
}
 
 

14. isBST2() Solution (C/C++)

/*
 Returns true if the given tree is a binary search tree
 (efficient version).
*/
int isBST2(struct node* node) {
  return(isBSTUtil(node, INT_MIN, INT_MAX));
}

/*
 Returns true if the given tree is a BST and its
 values are >= min and <= max.
*/
int isBSTUtil(struct node* node, int min, int max) {
  if (node==NULL) return(true);

  // false if this node violates the min/max constraint
  if (node->data<min || node->data>max) return(false);

  // otherwise check the subtrees recursively,
  // tightening the min or max constraint
  return
    isBSTUtil(node->left, min, node->data) &&
    isBSTUtil(node->right, node->data+1, max)
  );
}
 

15. TreeList

Yesterday i started to play some hours with mel , but i remembered the recomendations of rodrigo culagovski (www.culagovski.net – www.parametrica.org) about the benefits and advantages of python. So, i stopped with mel and put my hands into python.

im just starting with this , so im not to excited yet with the results (im waiting for better implementation of python in rhino 5), but i was able to do some simple triangle panels on a surface.

some guy told me once “show me the code”, so…

import maya.cmds as mc
srf = mc.ls(sl=True)
umin = mc.getAttr (’arrObj.minValueU’)
umax = mc.getAttr (’arrObj.maxValueU’)
vmin = mc.getAttr (’arrObj.minValueV’)
vmax = mc.getAttr (’arrObj.maxValueV’)
numlist=12
Div= 12
arrpt=[]
for i in range(numlist):
arrpt.append([0]*Div)
for x in range (numlist):
for y in range (Div):
arrparamU= umin + x *(umax-umin)/Div
arrparamV= vmin + y *(vmax-vmin)/Div
arrpt[x][y]= mc.pointOnSurface (srf[0],u=arrparamU,v=arrparamV,top=True)
for x in range (1,Div,1):
for y in range (1,Div,1):
crv1= mc.curve(d=1,p=[(arrpt[x-1][y-1]),(arrpt[x-1][(y)]),(arrpt[(x)][(y)]),(arrpt[x-1][y-1])])
crv2= mc.curve(d=1,p=[(arrpt[x-1][y-1]),(arrpt[(x)][(y)]),(arrpt[x][y-1]),(arrpt[x-1][y-1])])
mc.planarSrf( crv1,d=1 )
mc.delete (crv1)
mc.planarSrf( crv2,d=1 )
mc.delete (crv2)

after some hours learning some basic stuff  of the sintax of python, i think i´m able to work on some really cool stuff (not this basic boring stuff, hahaha)

SEO specialists provide an interesting role in our modern world.  Proper search engine optimization requires you to understand both algorithms and people.

If you understand people but not algorithms, you’ll build a perfect page that no one can find.

However, if you understand algorithms but not people, you’ll build an easily found page that no one wants to use.

In my time on the web, I’ve seen both kinds of pages.

Archiving Angels hover over as we educate the algorithm with love.

Here is a headless girl who satisfies all aesthetic.

Nike of Samothrace circa 440BCE courtesy of LOUVRE paris, and early Greek aesthetics.

SEE also: Archiving Angels… [page]

On a recent date, as my beau gulped at the bill, I thought to myself, “Aw Christ, now I have to blow him.” There’s a good reason it’s called a sexual favor; unless you reeaallyy like the guy, it is wholly unappetizing. And I am simply marking time and gathering fodder for this very blog with this poor lad (there is no parallel for guys because they aren’t required to shove anything past their epiglottis. Pansies).
But this acknowledgement of owing him something got me thinking about the role numbers play in dating; there’s your phone number, number of past sex partners, number of dates before you decide to either bang him or bail on him, and of course, the number I currently found myself calculating— price point. For example, my date this evening seems to think that X amount of money entitles him to a goodnight kiss before I turn into a pumpkin at midnight. And I think I need some sort of complicated algorithm to decipher the code, because every man seems to have a different idea of what an expensive date is (you’d think it is directly proportional to how much money he makes, right? Not so! It seems to be more about how much money Mommy and Daddy give him for allowance every week…).
Crass as it may be to discuss, even perfect gentlemen do expect something in return after taking a lady out. I like to think they’re in it for the pleasure of my company. But a brutally honest male friend recently laid it out for me. “Dixie,” he sighed, “if you let a guy take you out, if you let him pay, he wants to fuck you.” I could get up on my high horse about this, but the fact is, he’s right. So after a date or two, I make it explicitly clear to every guy I see that I am looking for something casual, and that I am dating a wide variety of men. I will not be his girlfriend. And I’m not personally someone who can handle sleeping around without getting emotionally attached. Ergo, no dice, buddy. I like to end that conversation with a chipper, “Take it or leave it.” Amazingly, no one ever leaves it. At first it was flattering, but I’ve recently realized that these guys seem to think I’m issuing a personal challenge. I do like playing hard to get, but when it comes to sex I’m incredibly picky about whom I engage. Yet for all my big talk, I recognize that the art of bargaining has a role here. Tonight’s contestant clearly finds his investment in my company worth at least a goodnight kiss. That’s totally fine, because he is kissable, but I know that if I want to avoid some serious whining, and keep him happy, I need to suck it up (sorry, couldn’t resist;).
On a first date few guys will bat an eye about picking up the tab. But after a few tete-a-tetes sans tits, they get antsy. I understand it, even if I’m mildly insulted.

Different search engines use a method of determining the websites that would be presented in the search page.  This method is actually known as the link popularity algorithm wherein the ranking of a website is determined by the number of links that lead to a particular webpage.  Therefore, in order to establish ones website in the highest rankings, it is important to establish links.  The difficult task however lies on building links.  Although there are a number of different methods of link building & link building services, the big question is really on how to build these links.

Building links is a skill that can be developed.  There are actually limitless boundaries on the extent and possibilities of link building.  However, as in any case, not all possibilities work for certain websites, such that it is very vital to determine the best approach that would work for you.  Here are some tips that may prove helpful in building links:
Start a List.  The most basic thing that one could do in building links is making a list. This list would contain the materials that you will need for building links.  These materials include articles, resource lists for specific topics, and gurus list.  These would comprise your prospect links.   The articles might be on tips, or methods, or clues. This is so because, these tenor of writing are the easiest way for people to relate to.  Therefore, if these articles could answer simple questions that people may ask in their daily endeavors, then you can establish the link already.  The gurus could aid in link building if you would be able to impress them enough to have them include you as one of their links.
Establish Easy Accessibility.  In building links, it is very important that a lot of people can relate to what you are trying to convey.  Therefore, the need for simplicity and conciseness in the content is a must.  Moreover, if you want authoritative people to link to your site, you have to be very careful with grammatical errors, and spelling errors.  You will have to remember that in order to have more links; a lot of people should be enticed into your page.  In addition, it is also important to exude an aura of trust and credibility.

Give Time for Reviews.  The internet is a social market where there are different products and services that are being offered.  One must take note though that not all of these products are well established, therefore if you take time for reviews on these products, it could help in building links.  If you do product reviews, these products will therefore link to your site for people to be able to read the review.

Give a positive integer n, generate all partition of n to an arithmetic series with common difference 1.

First, a straightforward solution:

import Data.List (find)
import Data.Maybe (catMaybes)

-- partition positive integer n to an arithmetic series
partitionToArithmetic0 n = catMaybes $ map partition [1..(n-2)]
    where
        partition x = let ys = [x..(n-1)] in
            case find (p x) ys of
                Just y  -> Just (x, y)
                Nothing -> Nothing

        p x y
            | (x+y) * (y-x+1) == 2 *n = True
            | otherwise               = False

Second, a not so straightforward solution, but much more effective than the first:

partitionToArithmetic1 n = catMaybes $ map partition [2..hh]
    where
        hh = floor $ sqrt $ fromIntegral $ 2*n

        partition h
            | not $ s > d = Nothing
            | not $ or [ hr /= 0 && nh == 0, hr == 0 && 2*nh == h] = Nothing
            | otherwise = Just (s-d, s+d1)
          where
            s = n `div` h
            d = (h-1) `div` 2
            d1 = d + (if even h then 1 else 0)
            hr = h `rem` 2
            nh = n `rem` h

You can check these two solutions are equal (upto n) by

test u = and $ map (\n -> (reverse $ partitionToArithmetic0 n) == partitionToArithmetic1 n) [1..u]

Exercise: Prove solution two is right.
Answer:
Let hight (or length) of an arithmetic series partition of a positive integer n is h, and

    s  = n/h - (n % h)
    d  = floor( (h-1) / 2)
    d1 = d + (if even h then 1 else 0)

We’ll prove it by three steps.

Step 1, [s-d .. s+d1] is an arithmetic series partition of the positive integer n.

    (s-d + s+d+[even h]) (s+d+[even h] - (s-d) + 1) / 2
    = (2*s + [even h]) (2*d + [even h] + 1) /2
    = (2*s + [even h]) * h / 2
    = n - (n % h) + [even h] * h / 2

    If [even h] * h = 2 * (n % h), we have sum [s-d .. s+d1] = n.
    ([even h] = if even h then 1 else 0)

Step 2, an arithmetic series partition of the positive integer n can be write as [s-d .. s+d1].

To prove this, we only need to prove that s = n/h – (n%h)/h.

    (s-d + s+d+[even h]) (s+d+[even h] - (s-d) + 1) / 2 = n

so

    s = n/h - [even h]/2

Because [even h] * h = 2 * (n % h), so we have s = n/h – (n % h)/h.

Step 3, h <= sqrt (2*n).

For partition n = h + (h-1) + … + 2 + 1, h get maximum value.

    (2 + (h-1)) * h / 2 >= n

so

    h * (h+1) >= 2*n

If h = sqrt (2*n), h * (h + 1) = 2*n + sqrt (2*n) > 2*n.

Some images from my final project for my master degree thesis. its a parametric bridge with a parametric skin – (hexatect). All the project it´s defined by scripting (rhinoscript) and some specific grasshopper definitions (vb.net) .

I finally presented my thesis (to get the architect title and a master degree (2×1 super combo, hahaha) last month, and i got the maximum calification ( 7.0 out of 7.0!!!). im still celebrating , so when the celebration stops, i will post my thesis in PDF and the most important rhinoscript tools that i wrote for the projects.

stay tuned to eSCRIPT-O

From SEED Magazine:

A new breed of architectural objects, inspired by theoretical science, is changing how we think about building and what counts as art.

“Transitory Objects,” the latest exhibit at Vienna’s influential Thyssen-Bornemisza Art Contemporary gallery, features some of the most innovative and splendidly unconventional forms coming out of the architectural world today, including works from Matthew Ritchie, Neri Oxman, Alisa Andrasek, François Roche, Greg Lynn, and Hernan Diaz Alonso. To have these mesmerizing structures together in one exhibit is remarkable in itself, but to have them positioned alongside works of contemporary art, as this exhibit has done, raises a provocative point about how boundaries have collapsed between architectural objects, conceptual art, and theoretical science. The exhibit aims to look at those architectural works that “have achieved an appearance of being autonomous forms,” says curator Daniela Zyman, suggesting that these works are meaningful outside of a specific context or place.

Ritchie, Oxman, Roche, and their colleagues split deeply from the finite, permanent, and utilitarian tradition of architecture. Not to say their end products are not useful or habitable. In fact, their structures are arguably better suited to the constantly morphing, impermanent, and aesthetically driven needs and desires of modern society. Rather than working with an end product or useful context in mind, they focus on the process of producing a structure that follows certain laws or principles. These resulting objects rise from computational models and algorithms whose inputs are being drawn from or at least inspired by some of the most boundary-pushing and abstract ideas in science, like quantum physics or the multiverse theory.

“Transitory Objects” includes two elegant models from Alisa Andrasek/BIOTHING that are part of a design project called “Mesonic Emission,” a reference to mesons, subatomic particles composed of quarks. These designs are made from an algorithm that is based on behaviors of electro-magnetic fields and is sophisticated enough to respond to the shape of the environment and to “grow” around obstructing objects. [For details about the algorithm, click here].

Read the full article.

I just added a new article, an introduction to bezier curves, which you can read here. It covers some theory about bezier curves, how to calculate them, an algorithm and some useful sourcecode.

I wrote this as part of a first publication at a new Blitz magazine website, blitzmaxcoder.com – which is currently going through a birthing process. I thought it would be a good idea to share it with the world here as well.

Of course, this means that I had to add a new section to the site – Articles – just click on the tab above

::Educate::the::algorithm::
::with::love::

…
to be continued
obviously.

(c) Etta B Dickerson, 2009

check out a new way to archive yourself…a knowledge base project.
…a knol is a knoll is a knol…

~nocturnal awake+asleep at computer~~

Two researchers have found that a pair of antifraud methods intended to increase the chances of detecting bogus social security numbers has actually allowed the statistical reconstruction of the number using information that many people place on social networking sites.

Read the full article on Ars Technia.

Äs I sit and drink tea in my break, I ask my colleagues for six words each. From these words come a  tea-tale to be told. 

Today’s words:

6/7/09:   Pineapple, garage sale, light bulb, minor, algorithm, bikini, Cronulla, helmet, Neanderthal, mannequin

I sensed the shadow fall over my face. I opened my eyes, my pupils adjusting to the shape of Matilda, who was standing beside me.

“Mattie, you’re blocking my sun.” I lifted my head to complain as I flicked sand up her leg with my foot. She was oblivious to my plea with her earphones wedge firmly in place and her hand tightly wrapped around her new iPod. She moved rhythmically in time to an unheard tune. 

I looked up at her Amazonian figure. She was clad in the world’s briefest bikini. Her skin was tanned and smooth over perfectly defined muscles. She shifted her weight from one long lean leg to the other, miming words as her body swayed in time to a silent beat. She was the beautiful one of our trio. She was the musketeer with the Bust of Fear. Her boobs were weapons of mass destruction. And she knew it. She snapped up guys with the blink of an almond shaped eye and broke hearts on a regular basis. She raked a lean bony hand through her hair, which fell in long blonde waves down her back. She scanned the beach; her head like a sideshow alley clown roving from one side to the other. Always looking. Always searching for the one. 

Utilising her shadow for good, I rolled on my side and dipped my hand into the small esky that sat between Lucy and me. I fished through the containers and pulled out a chunk of fresh pineapple. I took a bite, the juice dribbling down my face and neck. The tide was rolling back in and seagulls dipped and swerved overhead. The smell of coconut oil drifted past and I took a deep breath. Another month and summer would be over. 

I wiped at the pineapple juice and rested my head back down on my sandy-mound pillow. I could feel a sudden vibration under my head. I looked up and over, beyond where Lucy lay with her eyes shut tight, ignoring the world. A couple of lifesavers carried a surf ski between them, their feet digging hard into the sand, squeaking their way past us. The weight of the hull bulged muscles beneath their berry brown skin. ‘Cronulla SLSC’ was printed down one side of the ski. 

I watched them plough like human dune buggies, flicking back sand as they powered down to the water to slide into the foamy blueness. With the ski in the water, one hopped in and began paddling, leaving his mate behind, land locked as his feet formed watery graves in the sand. His mate waved and then watched, mannequin still, as the ski rose and fell to slice through the waves. 

I turned back to Mattie, who was still blocking my sun and oblivious. I was surprised to see she was paying zero attention to the muscle man surf ski parade. She was staring toward the surf club, near where we’d parked the car.

“Mattie, get outta my sun,” I called. I nudged her with my foot.

“What?” she asked. She pulled an earphone plug from her head.

“You’re in my sun…shove over,”

She took a step to the left and shoved the earphone back in place, the rhythmic twisting taking over her body again as she stared up at the surf club.

“She’s in scan mode,” Lucy said, opening one eye and turning to look at me. Lucy clenched her fists and raised her index fingers, sweeping them in radar like arcs.

“Doot..doot.doot…doot….’ she added, sounding more like a soviet sub. Lucy readjusted her skull on her mini-head rest. She’d bought it for five bucks in agarage sale. She’s the economist of the trio; the musketeer with the spending fear. There was no buying up big for her at the surf club canteen. Supplies for the day came from Lucy, and were neatly packed in the esky between us.

“So who’s she scanning for?” I asked quietly. I flipped over onto my belly and prepared myself for a scandalous side mouthed conversation.

“Probably the Neanderthal she met at Aiden’s party.” Aiden was Lucy’s cousin.

“No way…” I scooped up sand in my hand and watched as the grains sifted straight through my fingers. I missed Aiden’s party because of my grandmother’s eightieth birthday.

“Totally way…you should have seen them. Dis…gust…ing,” Lucy answered.

“God, another one bites the dust.” It was hard to take Mattie’s love life seriously. She wasn’t known for her fickle taste and came recommended for her abundant love.  A minor affliction, I suppose, when you looked like a Nordic goddess. Mattie had an algorithm for love. ‘Are they male-> yes…do they adore me-> yes…are they rich/exotic/drop dead gorgeous/ funny and charming-> yes…then thou shall be mine and mine alone…until the next one comes along.’ 

I glanced up at the surf club. Some surfers had gathered by the guard rail fence near the club. The sound of a horn bleated out from the car park and was followed by the roar of a mean looking cycle that pulled up not far from the clubhouse. The bike’s engine died with a final growl and the rider swung himself from the seat and ambled toward the railing that separated the beach from the sidewalk. He pulled off his helmet and tugged at the zip on his jacket, unzipping it slowly as he parked one butt cheek against the fence rail. He tucked his helmet under one arm and slid his glasses from his face. His hair was dark and long and from what I could see, his face was slightly more menacing. Beside the surfers, he looked like an evil black crow perched among a nest of white bunnies; dangerously out of place. 

 Mattie’s legs appeared beside me. I watched as she moved away, breaking into a run up the beach. Her earphones were out and dangling, her secret beat escaping unheard into fresh air.

“Hey, where are you going?” I called to her. She turned and looked at me, walking backward through the sand. Her smiling face lit up like a light bulb.

“I’ll be back in a while,” she said, turning and breaking into her infamous Baywatch run. I watched as she climbed the stairs to the clubhouse. She passed by the surfers without a glance and headed straight toward Bikie Boy. He had lifted his butt off the rail and was walking toward her like a misplaced Hawaiian Hagrid.  

I winced as Mattie threw herself up against him, disappearing behind the black flap of his jacket.

“Mission control we have lift off…” I said to Lucy. Lucy opened her eyes and looked over at me. I nodded toward the happy couple. They were halfway down each other’s tracheas.  Lucy flipped over and stared as Mattie and Bikie boy stood mauling each other to death.

“God, he is a Neanderthal. You failed to mention he was a bikie,” I said, looking over at Lucy.

” That’s not the guy from the party,” she said.

“Who is it then?”

“Dunno but I think we’re about to find out,” she said.

I looked over to see Mattie and Bikie Boy heading down onto the sand. The ocean roared in the background and seagulls screeched overhead. The calm of the beach had suddenly been replaced with a feeling of dread. There was something not right. I pushed myself up from the sand and sat waiting. They made their way across the sand like explorers searching for treasure.

I wish I knew then what was at stake and how much we would all end up paying. I wish there was some way I could have known how wrong things were about to become.

This is an old project I made for university with some colleagues. It’s made in Max/MSP and it uses a simple generative algorithm to drive notes to 5 sound generators using FM synthesis. It can become addictive!

Pretty much all of my students have, at some point or another, seen a really easy question on the GMAT, and had a mild panic attack as a result.  We all know that the test is adaptive; if, say, question #25 seems really easy, doesn’t that mean that the test-taker is doing really really badly?

No, of course not.

Well, okay… maybe.  If you’re doing really badly, you probably will see some really easy questions, particularly on the math section of the test.  But there are other possible explanations.  Chances are, you’ve heard them before; based on my experience, these familiar explanations still don’t prevent you from freaking out a little bit.

First of all, there are plenty of experimental questions on the GMAT test.  You might be kicking some serious butt, and then a complete softball comes your way.  Is it a sign that you weren’t really kicking butt?  Probably not.  You might just have received a little unscored nugget.  Answer the question as if it counts, and then put it out of your head.

I’m also convinced that the GMAT algorithms group questions by topic, and the test actually accounts for your performance on each topic.  You might have done wonderfully on the first, say, 12 questions on the GMAT, but then you miss your first geometry question.  Perhaps the test recalls that you screwed up on geometry, and then gives you an easy geometry question next time.  This is just speculation on my part, but I think it’s possible that seemingly easy questions might come at you when you’ve displayed weakness on a particular topic–even if you haven’t, in general, shown yourself to be a weak test-taker.

Most importantly, you should never worry about the difficulty level of the questions.  If a question seems easy, read it really, really carefully–it might not be as easy as you think, or you might be missing something crucial in the question.  And even if it is easy, why the hell would you want to waste your energy worrying about it?  Get the question right, and worry about your score at the end.

This might seem obvious to you, and this post is obviously just a little bit of nagging.  But it’s funny how many people apparently need to be reminded that they shouldn’t waste their time thinking about the algorithm and their score during the test.