intothecontinuum:

800x800

Mathematica code:

Graphics[
 GraphicsComplex[
  Table[
   {-.9908^n*Sin[n*3.87613], .9908^n*Cos[n*3.87613]}, {n, 0, 750}],
  Polygon[Table[i, {i, 1, 750, 1}]]], 
 PlotRange -> 1, ImageSize -> 800]

smarterplanet:

How The $25 Computer Could Change The Way We Learn, Work & Play - PSFK

The Raspberry Pi is a very basic looking micro-board that hides a sophisticated computer – the UK developers behind the computer expect other companies, hackers and DIYers to add their own peripherals and even casing. What’s buzzing the technology scene is the price. At $25 plus shipping, the inventors believe that the Raspberry Pi can revolutionize education – but they don’t expect its impact to just stop there. PSFK spoke to the Executive Director of the Raspberry Pi Foundation, Eben Upton, about what he and his team had created and the changes it might help create.

OK. The dumb question: Why does your computer look like one of those cards you stick in the back of a desktop computer? It’s not quite as cute as an iPad. Where’s the shell?

We’re expecting community members to design (and sell) their own shells for the device. In fact, both our distribution partners (element14/Premier Farnell and RS Components) will be marketing their own shells too.

via PSFK: 

Slower mouse movement is better, but this is definitely a sketch for faster machines. Check out the difference between this and the java version…

/*
Circus Fluid
Made by Jared "BlueThen" C. on June 5th, 2011.
Updated June 7th, 2011 (Commenting, refactoring, coloring changes)
 
www.bluethen.com
www.twitter.com/BlueThen
www.openprocessing.org/portal/?userID=3044
www.hawkee.com/profile/37047/
 
Feel free to email me feedback, criticism, advice, job offers at:
bluethen (@) gmail.com
*/

/* Frame rate control */
float div1000;
byte frate;
 
/* Variables for the timeStep */
long previousTime;
long currentTime;
float timeScale = .3; /* Play with this to slow down or speed up the fluid (the higher, the faster) */
final int fixedDeltaTime = (int)(10 / timeScale);
float fixedDeltaTimeSeconds = (float)fixedDeltaTime / 1000;
float leftOverDeltaTime = 0;
 
/* The grid for fluid solving */
GridSolver grid;
 
void setup () {
  size(320, 240, P2D);
  frate = 12;
  div1000 = (1000/frate);
  frameRate(frate*2);
  colorMode(HSB, 255);
  noStroke();
   
  /* grid = new GridSolver(integer cellWidth) */
  grid = new GridSolver(8);
}
 
void draw () {
  /* Frame rate control of Iteration */
  short time = (short)(millis() % 1000);
  
  if(div1000 >= (time % (int)div1000)) { 
    /* The ripple size will be determined by mouse speed */
    float force = dist(mouseX, mouseY, pmouseX, pmouseY) * 255;
   
    /* This is bresenham's line algorithm 
    // http://en.wikipedia.org/wiki/Bresenham's_line_algorithm
    // Instead of plotting points for a line, we create a ripple for each pixel between the
    // last cursor pos and the current cursor pos */
     
    float dx = abs(mouseX - pmouseX);
    float dy = abs(mouseY - pmouseY);
    float sx;
    float sy;
    if (pmouseX < mouseX)
      sx = 1;
    else
      sx = -1;
    if (pmouseY < mouseY)
      sy = 1;
    else
      sy = -1;
    float err = dx - dy;
    float x0 = pmouseX;
    float x1 = mouseX;
    float y0 = pmouseY;
    float y1 = mouseY;
    while ( (x0 != x1) || (y0 != y1)) {
      /* Make sure the coordinate is within the window */
      if (((int)(x0 / grid.cellSize) < grid.density1.length) && ((int)(y0 / grid.cellSize) < grid.density1[0].length) &&
        ((int)(x0 / grid.cellSize) > 0) && ((int)(y0 / grid.cellSize) > 0))
        grid.velocity[(int)(x0 / grid.cellSize)][(int)(y0 / grid.cellSize)] += force;
      float e2 = 2 * err;
      if (e2 > -dy) {
        err -= dy;
        x0 = x0 + sx;
      }
      if (e2 < dx) {
        err = err + dx;
        y0 = y0 + sy;
      }
    }
  }
  /* End of Iteration */
  
  /******** Physics ********/
  /* time related stuff */
   
  /* Calculate amount of time since last frame (Delta means "change in") */
  currentTime = millis();
  long deltaTimeMS = (long)((currentTime - previousTime));
  previousTime = currentTime; /* reset previousTime */
   
  /* timeStepAmt will be how many of our fixedDeltaTimes we need to make up for the passed time since last frame. */
  int timeStepAmt = (int)(((float)deltaTimeMS + leftOverDeltaTime) / (float)(fixedDeltaTime));
   
  /* If we have any left over time left, add it to the leftOverDeltaTime.*/
  leftOverDeltaTime += deltaTimeMS - (timeStepAmt * (float)fixedDeltaTime);
   
  if (timeStepAmt > 15) {
    timeStepAmt = 15; /* too much accumulation can freeze the program! */
    println("Time step amount too high");
  }
   
  /* Update physics */
  for (int iteration = 1; iteration <= timeStepAmt; iteration++) {
    grid.solve(fixedDeltaTimeSeconds * timeScale);
  }
   
  grid.draw();
  /*println(frameRate);*/
}
 
/* If the user clicks instead of drags the mouse, we create a ripple at one spot. */
void mouseClicked () {
  float force = 250000;
  if (((int)(mouseX / grid.cellSize) < grid.density1.length) && ((int)(mouseY / grid.cellSize) < grid.density1[0].length) &&
    ((int)(mouseX / grid.cellSize) > 0) && ((int)(mouseY / grid.cellSize) > 0)) {
    grid.velocity[(int)(mouseX / grid.cellSize)][(int)(mouseY / grid.cellSize)] += force;
  }
}

/* GridSolver Class 
 Velocity: How fast each pixel is moving up or down
 Density: How much "fluid" is in each pixel.
 
 *note*
 Density isn't conserved as far as I know.
 Changing the velocity ends up changing the density too. */
 
class GridSolver {
  int cellSize;
   
  /* Use 2 dimensional arrays to store velocity and density for each pixel. */
  /* To access, use this: grid[x/cellSize][y/cellSize] */
  float [][] velocity;
  float [][] density1;
  float [][] oldVelocity;
  float [][] oldDensity;
  int sx;
  int sy;
   
  float friction = 0.58;
  float speed = 20;
   
  /* Constructor */
  GridSolver (int sizeOfCells) {
    cellSize = sizeOfCells;
    sx = int(width/cellSize);
    sy = int(height/cellSize);
    velocity = new float[sx][sy];
    density1 = new float[sx][sy];
  }
   
  /* Drawing */
  void draw () {
    for (int x = 0; x < velocity.length; x++) {
      for (int y = 0; y < velocity[x].length; y++) {
        /* Sine probably isn't needed, but oh well. It's pretty and looks more organic. */
        fill(127 + 127 * sin(density1[x][y]*0.0004), 255, 127 + 127 * sin(velocity[x][y]*0.01));
        rect(x*cellSize, y*cellSize, cellSize, cellSize);
      }
    }
  }
   
  /* "Fluid" Solving
   Based on http://www.cs.ubc.ca/~rbridson/fluidsimulation/GameFluids2007.pdfwww.bluethen.com
www.twitter.com/BlueThen
www.openprocessing.org/portal/?userID=3044
www.hawkee.com/profile/37047/
 
Feel free to email me feedback, criticism, advice, job offers at:
bluethen (@) gmail.com
*/

/* Frame rate control */
float div1000;
byte frate;
 
/* Variables for the timeStep */
long previousTime;
long currentTime;
float timeScale = .3; /* Play with this to slow down or speed up the fluid (the higher, the faster) */
final int fixedDeltaTime = (int)(10 / timeScale);
float fixedDeltaTimeSeconds = (float)fixedDeltaTime / 1000;
float leftOverDeltaTime = 0;
 
/* The grid for fluid solving */
GridSolver grid;
 
void setup () {
  size(320, 240, P2D);
  frate = 12;
  div1000 = (1000/frate);
  frameRate(frate*2);
  colorMode(HSB, 255);
  noStroke();
   
  /* grid = new GridSolver(integer cellWidth) */
  grid = new GridSolver(8);
}
 
void draw () {
  /* Frame rate control of Iteration */
  short time = (short)(millis() % 1000);
  
  if(div1000 >= (time % (int)div1000)) { 
    /* The ripple size will be determined by mouse speed */
    float force = dist(mouseX, mouseY, pmouseX, pmouseY) * 255;
   
    /* This is bresenham's line algorithm 
    // http://en.wikipedia.org/wiki/Bresenham's_line_algorithm
    // Instead of plotting points for a line, we create a ripple for each pixel between the
    // last cursor pos and the current cursor pos */
     
    float dx = abs(mouseX - pmouseX);
    float dy = abs(mouseY - pmouseY);
    float sx;
    float sy;
    if (pmouseX < mouseX)
      sx = 1;
    else
      sx = -1;
    if (pmouseY < mouseY)
      sy = 1;
    else
      sy = -1;
    float err = dx - dy;
    float x0 = pmouseX;
    float x1 = mouseX;
    float y0 = pmouseY;
    float y1 = mouseY;
    while ( (x0 != x1) || (y0 != y1)) {
      /* Make sure the coordinate is within the window */
      if (((int)(x0 / grid.cellSize) < grid.density1.length) && ((int)(y0 / grid.cellSize) < grid.density1[0].length) &&
        ((int)(x0 / grid.cellSize) > 0) && ((int)(y0 / grid.cellSize) > 0))
        grid.velocity[(int)(x0 / grid.cellSize)][(int)(y0 / grid.cellSize)] += force;
      float e2 = 2 * err;
      if (e2 > -dy) {
        err -= dy;
        x0 = x0 + sx;
      }
      if (e2 < dx) {
        err = err + dx;
        y0 = y0 + sy;
      }
    }
  }
  /* End of Iteration */
  
  /******** Physics ********/
  /* time related stuff */
   
  /* Calculate amount of time since last frame (Delta means "change in") */
  currentTime = millis();
  long deltaTimeMS = (long)((currentTime - previousTime));
  previousTime = currentTime; /* reset previousTime */
   
  /* timeStepAmt will be how many of our fixedDeltaTimes we need to make up for the passed time since last frame. */
  int timeStepAmt = (int)(((float)deltaTimeMS + leftOverDeltaTime) / (float)(fixedDeltaTime));
   
  /* If we have any left over time left, add it to the leftOverDeltaTime.*/
  leftOverDeltaTime += deltaTimeMS - (timeStepAmt * (float)fixedDeltaTime);
   
  if (timeStepAmt > 15) {
    timeStepAmt = 15; /* too much accumulation can freeze the program! */
    println("Time step amount too high");
  }
   
  /* Update physics */
  for (int iteration = 1; iteration <= timeStepAmt; iteration++) {
    grid.solve(fixedDeltaTimeSeconds * timeScale);
  }
   
  grid.draw();
  /*println(frameRate);*/
}
 
/* If the user clicks instead of drags the mouse, we create a ripple at one spot. */
void mouseClicked () {
  float force = 250000;
  if (((int)(mouseX / grid.cellSize) < grid.density1.length) && ((int)(mouseY / grid.cellSize) < grid.density1[0].length) &&
    ((int)(mouseX / grid.cellSize) > 0) && ((int)(mouseY / grid.cellSize) > 0)) {
    grid.velocity[(int)(mouseX / grid.cellSize)][(int)(mouseY / grid.cellSize)] += force;
  }
}

/* GridSolver Class 
 Velocity: How fast each pixel is moving up or down
 Density: How much "fluid" is in each pixel.
 
 *note*
 Density isn't conserved as far as I know.
 Changing the velocity ends up changing the density too. */
 
class GridSolver {
  int cellSize;
   
  /* Use 2 dimensional arrays to store velocity and density for each pixel. */
  /* To access, use this: grid[x/cellSize][y/cellSize] */
  float [][] velocity;
  float [][] density1;
  float [][] oldVelocity;
  float [][] oldDensity;
  int sx;
  int sy;
   
  float friction = 0.58;
  float speed = 20;
   
  /* Constructor */
  GridSolver (int sizeOfCells) {
    cellSize = sizeOfCells;
    sx = int(width/cellSize);
    sy = int(height/cellSize);
    velocity = new float[sx][sy];
    density1 = new float[sx][sy];
  }
   
  /* Drawing */
  void draw () {
    for (int x = 0; x < velocity.length; x++) {
      for (int y = 0; y < velocity[x].length; y++) {
        /* Sine probably isn't needed, but oh well. It's pretty and looks more organic. */
        fill(127 + 127 * sin(density1[x][y]*0.0004), 255, 127 + 127 * sin(velocity[x][y]*0.01));
        rect(x*cellSize, y*cellSize, cellSize, cellSize);
      }
    }
  }
   
  /* "Fluid" Solving
   Based on http://www.cs.ubc.ca/~rbridson/fluidsimulation/GameFluids2007.pdf
   To help understand this better, imagine each pixel as a spring.
     Every spring pulls on springs adjacent to it as it moves up or down (The speed of the pull is the Velocity)
     This pull flows throughout the window, and eventually deteriates due to friction
  */
  void solve (float timeStep) {
    /* Reset oldDensity and oldVelocity */
    /* oldDensity = (float[][])density1.clone(); */
    oldDensity = new float[sx][sy];
    for (int i=0; i < sx; i++ ) {
      for (int j=0; j < sy; j++ ) {
        oldDensity[i][j] = density1[i][j];
      }
    }
    /* oldVelocity = (float[][])velocity.clone(); */
    oldVelocity = new float[sx][sy];
    for (int i=0; i < sx; i++ ) {
      for (int j=0; j < sy; j++ ) {
        oldVelocity[i][j] = velocity[i][j];
      }
    }
     
    for (int x = 0; x < velocity.length; x++) {
      for (int y = 0; y < velocity[x].length; y++) {
        /* Equation for each cell:
           Velocity = oldVelocity + (sum_Of_Adjacent_Old_Densities - oldDensity_Of_Cell * 4) * timeStep * speed)
           Density = oldDensity + Velocity
           Scientists and engineers: Please don't use this to model tsunamis, I'm pretty sure it's not *that* accurate
        */
        velocity[x][y] = friction * oldVelocity[x][y] + ((getAdjacentDensitySum(x,y) - density1[x][y] * 4) * timeStep * speed);
        density1[x][y] = oldDensity[x][y] + velocity[x][y];
      }
    }
  }
 
  float getAdjacentDensitySum (int x, int y) {
    /* If the x or y is at the boundary, use the closest available cell */
    float sum = 0;
    if (x-1 > 0)
      sum += oldDensity[x-1][y];
    else
      sum += oldDensity[0][y];
       
    if (x+1 <= oldDensity.length-1)
      sum += (oldDensity[x+1][y]);
    else
      sum += (oldDensity[oldDensity.length-1][y]);
       
    if (y-1 > 0)
      sum += (oldDensity[x][y-1]);
    else
      sum += (oldDensity[x][0]);
       
    if (y+1 <= oldDensity[x].length-1)
      sum += (oldDensity[x][y+1]);
    else
      sum += (oldDensity[x][oldDensity[x].length-1]);
       
    return sum;
  }
}

(Source: blogdotroll)

psykzz:

by rednor

kwikset:

“The Call of Duty Black Ops 2 trailer was released last night, and the internet is buzzing with speculations. Over at Kotaku, however, Brian Ashcraft noticed something a little concerning – at several points in Call of Duty’s promotional materials, a Guy Fawkes mask appears. Each time it does, it seems to be identified with a hacker “enemy.” The main plot from the game concerns hackers taking control of unmanned weapons in a near-future scenario..

This feels like something else. I’m sure that Treyarch will actively avoid every mentioning the word “Anonymous” in Black Ops 2, but it might as well have when it flashed the Guy Fawkes mask. By identifying Anonymous as “enemy,” the developer comes dangerously close to commenting on world politics with all the tact of a rocket launcher…

Anonymous is not an enemy. It’s a gigantic “organization” with no membership requirements and little to bind it besides a name and fluency with computers. Sons of bitches, thieves and honest-to-god freedom fighters alike wear the Guy Fawkes mask. There’s the possibility that some day, combat drones might be hacked by somebody wearing a Guy Fawkes mask. But I’m not comfortable with a game like Call of Duty connecting any dots..”~Read More: Forbes

The link to this video has been unlisted by youtube and the creators.. only those with the link can see it. Here’s the link: (http://youtu.be/frWTXI8_Nnk) to the synopsis trailer featuring the Guy Fawkes Mask in question which I will also embed:

Thank you to ibtimes (read their article here: anonymous-hackers-call-duty-black-ops-trailer) for helping to get this link out.

As if the entire Call of Duty series was not a blatant political strategy, complete with a rewrite of history, ethics and any respect for general fucking human dignity. Those games and the people who design them are bags of shit, dumping all over the efforts of conscientious souls who have toiled through the centuries to make mindless violence an unacceptable feature of reality. Put down the propaganda fodder and pick up a real weapon: a paint brush, a guitar, a notebook, a book on coding C, a microphone…

Modern color cycling… cool

(Source: createthefuckingchaos)

stylogicalmaps:

http://stylogicalmaps.blogspot.com/p/phono-divinoro.html
https://github.com/Revlin/phono_divinoro

p5lyon:

Please upgrade your browser to something new like Google Chrome.

Un petit guide pour intégrer facilement des…

EDIT: English version now
A little HOW TO to easily include Processing sketches in Tumblr, with tools to test/write Processing Code and fast format it for Tumblr:
http://p5lyon.tumblr.com/ProcessingJSTumblrEn