If you contract those jobs (offshore or not, doesn’t matter) out, where does that leave your potential for future growth?

Where do you find rising stars when there is nowhere to rise from?

Also, you can see it uses a rainbow color palette what to make it look pretty…

A couple of ideas have just occurred to me – one is that it might be neat to have different x and y step sizes. Also! It would be interesting to build flow-fields out of gray scale images… I might try that next just to see what happens.

via

I’m using Perlin Noise to generate this. I’m treating each point as an angle, generating the vector components, then storing it all in a screen-sized array. Then, I drop particles at random heights on the right-most part of the screen and update their positions from the vectors stored in the array. Then the drawing just sort of draws itself… It’s sort of like a giant game of Plinko.

Some pretty ugly stuff, this:

 
ArrayList displays;
float currentAngle = 0;
float currentX = 200;
float tempX = currentX;
float currentY = 150;
float tempY = currentY;
WormThing w1 = new WormThing(250,400,0);
WormThing w2 = new WormThing(250,400,180);
 
class MouseDisplay { 
  float x,y;
  boolean alive;
  private int telomere;
  float rotation_angle;
  float rotation_speed;
 
  MouseDisplay(float x_, float y_, int size_) { 
    x = x_;
    y = y_;
    alive = true;
    telomere = size_;
    rotation_angle = 45;
    rotation_speed = 10;
  }
 
  void show() {
    x = x+cos(radians(rotation_angle)) * rotation_speed;
    y = y+sin(radians(rotation_angle)) * rotation_speed;
    rotation_angle -= 10;
    ellipse( x,y, telomere, telomere);
    telomere--;
    if (telomere == 0) {
      alive = false;
    }
  }
}
 
class WormThing { 
   float angle;
   float x;
   float y;
 
   WormThing(float x_, float y_, float angle_) { 
      x = x_;
      y = y_;
      angle = angle_;
   }
 
   void execute() { 
      angle += 5;
      x += cos(radians(angle)) * 15;
      y += sin(radians(angle)) * 15;
      for (int i = 1; i < 5; i++) { 
         MouseDisplay d = new MouseDisplay(x+random(-10,10), y+random(-10,10), 100);
         if (displays.size() < 250) {
            displays.add(d);
         }
      }
    }
 
}
 
void setup() {
  size(600,800);
  frameRate(30);
  stroke(90, 60, 50);
  smooth();
  displays = new ArrayList();
}
 
 
void draw() {
 
  w1.execute();
  w2.execute();
 
  background(167, 159, 148);
  for (int i = 0; i < displays.size(); i++) {
 
    MouseDisplay m =  (MouseDisplay) displays.get(i);
    m.show();
    if (m.alive == false) {
      displays.remove(i);
    }
  }
  print(displays.size()+"\n");
}

What I was trying to get at is that there is more than one way to skin a cat or, if you prefer, to visualize a recursive set. In the last Koch example, the drawing code itself was recursive. We would see if we were at the terminal (bottom-most) depth and if so, draw a little bit of line. Otherwise, we would recursively call the drawCurve(…) function.

Instead of making the drawing code recursive, we can define the curve as a set of rules, evaluate those rules recursively, and use the Turtle from my last post to draw the whole curve!

The especially cool thing about this is that we can change the rules to draw whatever kind of self-similar shape we want, without having to do a bunch of math for each curve we want to draw.

About L-systems
An L-System is defined by a grammar. It has a starting state (sometimes called an axiom) and some rewriting rules. For the Koch curve, you’ll sometimes see the L-System defined like this:

Axiom: F
Rule: F -> F+F-F-F+F

I think people use pluses and minuses to make it look like math. Instead, you should think of each character in the Rule as an instruction for your turtle. F means “go forward”, + means turn left, – means turn right.

I wrote my Koch curve rule like this:

Axiom: f
Rule: f -> f l f r r f l f

For myself, “l” means turn left, and “r” means turn right.

Ok, so that’s all well and good, but how does this translate to a crazy self-similar curve? All I’ve shown you so far is a really simple grammar.

Well, the key is that the rule “f” rewrites itself. I’ll show you in the table below, for up to two iterations:

Ok, so for each iteration, you replace ‘f’ with ‘f l f r r f l f’. Once you’ve iterated enough times, you can tell your turtle to follow the instructions in that list.

Trouble is, when you fully expand the list, you see that it gets really big after just a couple of iterations. If you tried to just string replace 10 times, you would run out of memory. And don’t think about trying to get more memory, because if you doubled your memory, you might have enough for just one more iteration.

So, the way to overcome this is to evaluate the rules while we’re drawing. You’ll find the code for that in the function called evalutron, below:

Turtle t;
HashMap rules;
 
class Turtle {
  float x, y, ang;
  float default_angle;
  boolean down;   
 
  Turtle(float _x, float _y, float _ang) { 
    x = _x;
    y = _y;
    ang = _ang;
    down = false;
  }
 
  void penDown() { 
    down = true;
  }
 
  void penUp() { 
    down = false;
  }
 
  void forward(float len) { 
    float nx = x+cos(radians(ang))*len;
    float ny = y+sin(radians(ang))*len;
    if (down) { 
      line(x,y,nx,ny);
    }
    x = nx;
    y = ny;
  } 
 
  void turnLeft(float _ang) { 
    ang -= _ang;
  }
  void turnLeft() {
    ang -= default_angle;
  }
 
  void turnRight(float _ang) { 
    ang += _ang;
  }
  void turnRight() { 
    ang += default_angle;
  }
}
 
void execute(char chr, float zoom_factor) { 
  switch (chr) { 
  case 'l':
    t.turnLeft();
    break;
  case 'r':
    t.turnRight();
    break;
  case 'f':
    t.forward(zoom_factor);
    break;
  }
}
 
void evalutron(String state, HashMap rules, int depth, float zoom) { 
  for (int i = 0; i < state.length(); i++) { 
    char x = state.charAt(i);
    String result = (String) rules.get(x);
    if (depth > 0 && result != null) { 
      evalutron(result, rules, depth-1,zoom);  
    }
    else { 
      execute(x, zoom);
    }
  }
}
 
void setup() { 
  background(10);
  stroke(120);
  smooth();
  size(600,600);
  frameRate(30);
  /** 
   * Set up the L-System Rule
   */
  rules = new HashMap();
  rules.put('f', "flfrrflf");
  /** 
   * Configure our friendly turtle 
   */
  t = new Turtle(0,300,0);
  t.penDown();
  t.default_angle = 60;
  /*
   *  Evaluate the rule set, and draw the curve.
   *  'f' is the initial rule set. notice that 'f' is the rule in the rules map, 
   *  so it will get rewritten for each iteration.
   */
  evalutron("f", rules, 7, .28);
}

You see that evalutron just looks at the current token, evaluates the depth at which its evaluating, and decides whether to expand the current token to another ruleset, or to pass the command to the turtle. Easy as pie!

Oh, and if you’re paying very close attention, you’ll see that the turtle has changed a teeny bit: he can now turn a ‘default’ amount by calling turnLeft() and turnRight() with no parameters.

So anyways, this is another way to draw cool recursive sets, but in a way that’s a little more language-y and a little less math-y. Also, you can change the original ‘axiom’ or add new rules to get wildly different results. Try it!

As proof, here’s the applet in action. Sorry, no interaction this time:

<br /> You need java for this to work.. :-/<br />

But anyways, I made a Turtle. Here it is doing a random forward/backward walk (+/- 10 pixels) and turning left one degree for every frame. It’s oddly compelling to watch.

Oh hey, if your turtle wanders off the screen (unlikely in the short term, inevitable in the long term, sort of like death…) then just click on the applet to reset him back to the middle of the screen.

Also, thanks to my Mom for getting me a “Programming with LOGO book” when I was still a toddler. Apparently, those lessons weren’t lost on me…

<br /> You need java for this to work.. :-/<br />

Turtle t;
class Turtle {
  float x, y, ang;
  boolean down;   
 
  Turtle(float _x, float _y, float _ang) { 
    x = _x;
    y = _y;
    ang = _ang;
    down = false;
  }
 
  void penDown() { 
    down = true;
  }
 
  void penUp() { 
    down = false;
  }
 
  void forward(float len) { 
    float nx = x+cos(radians(ang))*len;
    float ny = y+sin(radians(ang))*len;
    if (down) { 
      line(x,y,nx,ny);
    }
    x = nx;
    y = ny;
  } 
 
  void turnLeft(float _ang) { 
    ang -= _ang;
  }
 
  void turnRight(float _ang) { 
    ang += _ang;
  }
}
 
void setup() { 
    background(10);
    stroke(120);
    smooth();
    size(600,600);
    frameRate(30);
    t = new Turtle(300,300,0);
}
 
 
void draw() {   
    if (mousePressed) { 
        t = new Turtle(300,300,0);
    }
    t.penDown();
    t.forward(random(-10,10));
    t.turnLeft(1);
}

<br /> You need java for this to work.. :-/<br />

void drawCurve(float x, float y, float len, float ang, float curve_angle, int depth) { 
   float sideLen = (len/6) / cos(radians(curve_angle));
   float ax = x+cos(radians(ang)) * len/3;
   float ay = y+sin(radians(ang)) * len/3;
   float bx = ax+cos(radians(ang-curve_angle)) * sideLen;
   float by = ay+sin(radians(ang-curve_angle)) * sideLen;
   float cx = bx+cos(radians(ang+curve_angle)) * sideLen;
   float cy = by+sin(radians(ang+curve_angle)) * sideLen;
   float dx = cx+cos(radians(ang)) * len/3;
   float dy = cy+sin(radians(ang)) * len/3;
   if (depth > 0) { 
     depth--;
     drawCurve(x,y,len/3,ang,curve_angle,depth);
     drawCurve(ax,ay,sideLen,ang-curve_angle,curve_angle,depth);
     drawCurve(bx,by,sideLen,ang+curve_angle,curve_angle,depth);  
     drawCurve(cx,cy,len/3,ang,curve_angle,depth);
   } else {
     line(x,y,ax,ay);
     line(ax,ay,bx,by);
     line(bx,by,cx,cy);
     line(cx,cy,dx,dy);
   }
}
 
void setup() {
  size(800,600);
  frameRate(30);
  background(0);
  smooth();
  stroke(60);
}
 
void draw() {
  background(0);
  float curve_angle = (90*mouseX/800);
  curve_angle=min(70,curve_angle);
  int detail_level = 7-(int) 8*mouseY/600;
  drawCurve(0,  300, 800, 0,  curve_angle, detail_level);
  drawCurve(800,  300, 800, 180,  curve_angle, detail_level);
}

But lately, there doesn’t seem to be any unifying strategy. A search engine here, a search engine there. Some new products.

But what is the vision?

Everyone knows that Google wants to own all information.

Apple wants you to buy all of your hardware from them. Or at least they want to make the slickest shit under the sun.

What does Microsoft want? A PC in your kitchen.

I first really noticed it in Windows XP. When setting up a network, the System Properties > Computer Name tab used “Kitchen Computer” as an example description. What an idea!

The birth of Kitchen Computing

At first, I thought this was just a bad decision from a software designer acting under extreme stress. But as I’ve investigated, a pattern of kitchen computing has emerged. This pattern has been emerged across multiple divisions of the company.

Here’s an article from Microsoft’s Windows XP site. It asks “How Useful is a Kitchen PC?” I don’t need to tell you that the answer is: “very useful.” Additionally this article states that you “can use almost any serviceable computer.”

Indeed.

In this article by Jerry Honeycutt, ostensibly intended to assist in the setup of a printer on a home network, helpfully suggests that you set up your printer on the “kitchen computer.”

In another article, Honeycutt asks the age-old question: “What if Junior is using the kitchen computer to play Asheron’s Call, but you want to print a recipe for Mom’s meatloaf?”

What if, indeed.

Here’s an article on the Microsoft Office website about how to “Move Your Computer Into the Kitchen.”

It states that it’s “no wonder so many families want computers in their kitchens.”

Why with all the printing and the Asheron’s Call, I can’t imagine why you wouldn’t want a PC in your kitchen!

But wait, there’s more! This silicon alley insider post says that the new touch screen technology that may (or may not) be supported could be used… in the kitchen!

Finally, we come to this horrible marketing hackery. A video about Windows 7 “launch parties.” You know? Like when you got your friends together to have some wine and cheese and tell them about Obama? It’s like that, except you’ll be telling them about the great new features in Windows 7:

Notice where they’re hanging out…. In the kitchen! Just hop to 2:23 and the lady in the middle says, “everyone just crowded around the computer in the kitchen!”

So, like, what’s the point? It seems like there’s really a unified effort. Like maybe they have a KPI for “mentions of the kitchen in marketing materials.” Or maybe some big-wig in Redmond read that once technology became ubiquitous (like the telephone) it became common in the kitchen.

I fear that they may have mixed up correlation and causation though. By marketing your crap to go into a kitchen, you’re not going to make it ubiquitous and hugely profitable, you’re just gonna get it into a kitchen. And you’ll look pretty silly in the process.

Yesterday, a co-worker asked me, “how much coffee do you drink?”  I answered honestly that I didn’t know.  To find out, I drew a picture of a coffee cup on my white board.  I also drew a line underneath.  Every time I got another cup, I drew another line.  (Incidentally, I also drew a smiley, neutral or grumpy face to help my co-workers know my mood before talking to me.)

I drank six cups of coffee today.  And I was only grumpy for about an hour, right after lunch.

So all this metricizin’ got me thinking about the health effects of drinking six cups of coffee per day, so I looked it up.  I performed several searches on Google to finally understand the progression of health effects as you drink more coffee.

Ask Dr. Google

I searched for “one cup of coffee per day”, then “two cups of coffee per day”, and so on, up to ten cups.  Without clicking any of the results, I was able to glean the health effects of each amount by reviewing the first page of results.  For the reader’s convenience, I have summarized the results in the following table:

As you can see, I’m right at the sweet spot, between “slightly lowered risk of death” and “hallucinations.”

Also, in case you didn’t feel like looking it up, Tachycardia means “Your heart is beating too fast.”