a digital scan of a 35mm film image of a processing sketch running on an LCD
Skip to Content

Big Screens is Coming

It’s coming up… December 3rd at the IAC building. Project descriptions and additional info here.

November 15 2010 at 9 PM

MacBook Pro Tick Fix

Disclaimer: This was not a particularly good use of my time.

With that out of the way, here’s a simple fix for anyone experiencing weird ticking noises from their late-model unibody MacBook Pros. Note that this is all a bit obsessive and off-kilter… but since no one else seems to have documented this fix I’ll make an exception and pollute the blog.

My otherwise-trusty 15” model has been giving off an obnoxious, metallic grating sound whenever the chassis flexes or whenever there’s a bit of pressure on the bottom of the case. (For example, when using the machine on your lap instead of on a flat / hard surface.) The sound’s very strange — kind of a combination of bed springs and crickets. It’s a purely mechanical sound, and occurs even when the machine is off. Here’s what it sounds like — you may need to turn your speakers up, as it’s a bit faint:

On the MacBook Pro, the entire chassis acts as an electrical ground. The bottom case cover also needs to be grounded, and Apple’s design maintains contact between the upper and lower portions of a case with a number of spring-loaded contact points. As the chassis flexes during handling, these contact points move slightly against the bottom cover to create the grinding noise documented above. Thus getting rid of the noise is a matter of reducing friction between the contact points and the bottom cover.

This problem has been extensively documented and discussed elsewhere. (The most thorough discussion I could find is this thread on the Apple support forums.)

Some people have gone so far as to remove the grounding spring sub-assembly entirely. This is probably fine, but it seems foolhardy to start ripping grounding points out of your rather expensive and static-sensitive laptop.

Some others have reportedly used small pieces of tape between the spring contacts and the bottom case… this also seems naïve since the tape will act as an insulator and compromise the grounding point.

My solution is to apply a small dab of conductive grease to each contact point. This completely eliminates the grinding sounds without compromising electrical contact between the upper chassis and bottom cover.

Here’s the step-by-step:

1. Gather Materials
You will need your laptop, some isopropyl alcohol, Q-Tips, a #00 phillips screwdriver, and conductive grease.

Note that you want electrically conductive silicone-based grease. Thermally conductive grease, like you would use between a CPU core and a heat sink, is generally designed to not be electrically conductive, and would be no better than using a layer of tape. I used a silver-impregnated silicone-based conductive grease from Chemtronics, part number CW7100. It’s tough to find and obscenely expensive. The best price I could find for a tube was $21 from All-Spec Industries. (And here’s a PDF of the datasheet, for those inclined.)

2. Remove the bottom cover
Remove the 10 screws securing the bottom cover to the chassis. Gently pry off the bottom cover.

3. Identify and clean the contact points
With the cover removed, you will see the offending pair of spring-loaded grounding contacts near the RAM in the center of the machine. (Enlarged at left.) On the bottom cover, you will see several other points of contact — about a dozen in all — identifiable by their slightly rough texture relative to the rest of the aluminum. (Right, circled in red.) Dip a Q-Tip in isopropyl alcohol and clean off each of these bottom-cover contact pads to make sure they’re free of oil and dirt before moving on to the next step.

4. Apply conductive grease
Add a tiny dab of grease to each of the 12 contact points. Try to keep it clean, and limit application to the confirmed points of contact. A detail of the center two contact points before grease application is at left, and the after is at right.

5. Remove conductive grease
You only need a thin layer of conductive grease to do the job, and you absolutely do not want any excess grease getting onto the logic board where it could create computer-killing short circuits. So after the initial dab of grease, take a couple clean Q-Tips and wipe off almost all of the grease you put down. The contact points should look something like this when you’re finished:

6. Reassemble
Replace the bottom cover, secure it with the 10 screws.

And that’s it… my machine has’t made a noise since.

Before you have a field day with your machine, make sure you’re actually dealing with this particular issue. There are a few other potential causes for similar sounds… a dying hard-disk sometimes makes clicking sounds, and even a healthy hard disk will make a small clicking sound if you move the machine suddenly and it decides to park the heads. If your machine makes the clicking sound even when it’s powered down and specifically when you apply pressure to the bottom cover, then you’re probably dealing with the issue described in this post.

I’ve only tested this in my 15” model. I know the same issue has been documented on the 17”, not sure about the 13”. If you have the ticking problem / success fixing your non-15” model let me know in the comments and I will update the article accordingly.

A quick disclaimer: This fix might void your warranty, although if you’re sparing with the grease I’m not sure an Apple-tech would notice. Use common anti-static sense: Be sure to ground yourself before opening up your computer. Don’t touch anything inside that you don’t absolutely have to.

November 5 2010 at 9 PM

Thesis Map

Thesis concept map

A few works / concepts / aesthetics related to the post-apocalyptic pirate internet.

Class discussion brought up the following:

  • The “no disasters” and “auto-disasters” drop-down options in Sim City 2000
  • Tension and contradiction between Dead Drops and The Temporary Autonomous Zone
  • “8 bit with curves”, zine aesthetic
  • Dead Drops’ illusion of deeper connection, despite being an isolated blind pouch
  • Banality of Evil
  • Firesheep
  • Screen recording
  • What can be untethered? Find analogous (and analog?) structures.
November 2 2010 at 1 PM

Metal Box

finished metal box

This week’s box is made out of… metal.

Work started with a nice big sheet of 20 gage cold-rolled A366 steel. This stuff also goes goes by the name “Alloy 1008” — which is 99% iron, with traces of carbon, manganese, phosphorus, copper, and sulfur. (Big thanks to Hana Newman for organizing a group-buy for the class.)

I decided to make a slightly smaller box than Peter demonstrated in class — opting for a 4” square footprint, with 1.5” tall sides. I added 1/8” in each dimension to account for the width of the bends. I started by cutting a 7 1/8” square sheet on the large metal sheer. The cuts wind up much cleaner if you bias the handle of the shear inward on the down stroke.

and then folded up the sides on the hand brake. Like all things in the ITP shop, the brake was slightly out of whack. I should have loosened and adjusted the removable blocks to put them into better alignment before making the bends.

Next I snipped and folded over the end tabs. My bends were slightly off, though, so the box ended up with one tab on the inside, and the other tab on the outside. Next time I’ll make sure the tabs are folded more precisely with respect to the first two bends.

Finally, rivets were used to hold the box together. Drilling holes for the rivets was tricky (particularly when the tabs were “inside” the box). I built a small jig with some wood to drill into a and a metal pin (a screw, in this case) that I could brace the box against and use to push the tabs into alignment during the drilling process. The whole thing clamps to the corner of the table so the box could “sit” on an inside wall without interference from the other side of the box.

The jig is at left, a close up of the cut from the metal shear is at right.

Drilling jifShear cuts

October 27 2010 at 12 PM

Project Status

The VHS Can(n)on is coming together, albeit a bit slowly. At this point I’m still in the process of gathering parts. So far I’ve secured a consumer-grade Sony VHS player with a jog dial and nice big play / pause buttons. I’ve also picked up a WiiMote (for pointer tracking) and a handful of VHS tapes courtesy of Sofy (Standards like Clueless, the original Star Wars trilogy, and a Daft Punk video).

I still need a means of getting the composite video feed from the VHS player into my computer (and from there into Processing or OpenFrameworks). I’m sifting through a bunch of different options from B&H.

Once that box is in hand, I’ll have enough to implement the most basic elements of the system. It’s important to do this soon since I’m not yet sure how much I’ll have to hack up the VHS player’s interface to build a usable set of interactions.

October 26 2010 at 6 PM

The Post-Apocalyptic Pirate Web Kit


This post captures a few notes from a second round of thesis brainstorming.

This time I took a completely different tack, exploring ideas surrounding sustaining the communities and knowledge present on the web without the need for a centralized infrastructure. What might happen, for example, of catastrophic technical or political events shut down ISPs — or if increasing regulation / paranoia leads to national firewalls or censorship? Could the web be rebuilt with the scraps of hardware most consumers already have on hand? Are WiFi routers, devices, and personal storage ubiquitous enough to patch together a mesh resembling the web as we know it today?

In the context of a thesis project, I envision answers to these questions manifesting as a kind of survival kit. A suitcase full of hard disks and wireless connections, for example, designed to restore fragments of the web to nearby users and act as a node in a broader network of data survivalists.

Here are a few questions to shape early exploration of the idea:

  1. How big is the internet? How about just the text? How much physical space would it take to store a copy of the whole thing?

  2. Build or find a wardriving app for the iPhone that will log SSIDs / MAC addresses / geo coordinates while walking around new york. From this data, I could find out how much of the area could (hypothetically) be covered by an ad-hoc mesh-based internet to verify the feasibility of the idea (at least in densely populated areas). WiGLE has been collecting wireless access point info since 2001, and they’ve aggregated and geo-tagged a list of about 27,500,000 WiFi access points so far. Here’s how coverage looks across the United States:
    wifi map

  3. What data do people take with them before they go off-grid?
    The subway, for example, is a wifi-free zone… and many riders descend with a few gigabytes of Mp3s at the least. More obsessive types might find ways to cache fragments of the web for consumption sans-connection.

October 26 2010 at 11 AM

Bits is Bits

So I have to help with a Drive By about math, which involves treading through territory covered last year by the ultra-smart Elie Zananiri. His take on the subject along with excellent notes and processing examples remains available on the world wide web.

I’d like to take a slightly different tack and give a little background on how computers think about numbers, where abstract numbers end and representational data begins, and how to manipulate this threshold to your advantage.

This is kind of a basic place to start, but it can be central to preserving your sanity when working on more complicated problems. Everything on your computer can be reduced to bits.

A bit is short for “Binary Digit”, it’s the atom of computation. Alone, a bit can only represent two possible numbers, because there are only two possible ways for a single bit to go: 0 or 1.

To represent larger numbers, we have to stick bits together into longer sequences. Usually, the smallest sequence we’ll work with is 8 bits, or a one byte.

Signed vs. Unsigned
You may have noticed the signed / unsigned keywords stuck before variable type names. This indicates whether or not the first bit in the sequence may be used to represent a number value, or whether it determines if the number is positive or negative. A 0 in the first bit of a signed value means the number is positive, a 1 means it’s negative.

But beware, and int isn’t an int — the number of bytes that make up a particular piece of data is contingent on the particular implementation of the programming language you’re using. In Processing for example, the integer is 32 bits of data, or 4 bytes. It’s also signed, this means it can represent values from -2,147,483,648 to 2,147,483,647. In the Arduino environment, however, an int is just 16 bits, or two bytes, which means you’re limited to representing values between -32,768 to 32,767. A quick way to determine how many values you can represent is the formula 2^(bit length) - 1. (Or 2^(bit length - 1) - 1 for signed types.)

In Processing, the binary() and unbinary() functions are extremely handy for seeing the bits behind the data, and vice versa.

Bits is Bits

If everything on your computer is just bits, then how do we decide what’s an image, what’s a sound file, what’s a text file, etc.?

Basically, these determinations is just oppressive dictums sent down from on-high by your operating system and a cabal of applications. You don’t have to subscribe to these narrow notions… nothing is stopping you from listening to images or reinterpreting music into text.

Cue Processing Demos:

  • bits_is_bits_cam_to_sound.pde
  • bits_is_bits_sound_to_image.pde
  • bits_is_bits_text_to_sound.pde

Really Big Numbers
In Processing, the largest number you can work with in the documented data types is a “long” — which is 64 bits of signed data, giving you 9,223,372,036,854,775,807. Lame. So what happens when you need to work with bigger numbers?

The way around these limitations is to use something called arbitrary precision arithmetic. Arbitrary precision arithmetic basically uses byte arrays of indeterminate (and conceptually infinite) length to allow you to do math with incredibly large numbers. They’re going to be much, much slower than using your programming language’s native data types, but when you need to work with really big numbers it’s a handy thing to have around.

The gold standard open-source option is the The GNU MP Bignum Library. There’s a big number library built into Java (and therefore Processing), you just need to explicitly load it and deal with its weird syntax. If you need one for ActionScript 3, talk to me. (Links pending!)

Here’s a quick example of breaking the 9 quintillion barrier in Processing:

  1. import java.math.BigInteger;
  3. void setup() {
  4.   BigInteger a = new BigInteger("9223372036854775807");
  5.   BigInteger b = new BigInteger("9223372036854775807");
  7.   BigInteger sum = a.add(b);
  9.   println(sum); // Decimal representation
  10.   println(sum.toString(2));  // Binary representation
  11. }

So why bother with this? If you can manipulate bit strings of arbitrary length, you can start to do math with pieces of data large enough to have representational value.

Cue another processing demo: bits_is_bits_every_image.pde

Gratuitous Tips

  • You can do basic math in the Mac’s spotlight search bar, command-space brings it up quickly.
  • The built in mac calculator has a programmer mode which shows you different representations of the same number. Pull up the calculator and press command-3 to switch into programmer mode.
  • Wolfram Alpha is super handy for doing arbitrary-precision calculations, balancing equations, graphing stuff, etc.
  • Hex Fiend is a great, free hex editor for the mac that makes it easy to pry into the numbers behind any file on your computer.

October 14 2010 at 5 PM