January 06, 2003
A computer that glows
There's an interesting piece by John Markoff in the New York Times today about a new Apple patent -- for a computer with a glowing, external, LED-covered case.
The company's United States patent application, No. 20030002246, entitled "active enclosure for a computing device," describes a machine that contains an array of rainbow-hued light-emitting diodes. It seems that the quirky computer maker is considering the manufacture of a machine that acts something like a mood ring — a computer whose shells change colors at the owner's whim.
Though Markoff doesn't make this connection, it sounds to me like Apple is creating an "ambient device." I wrote about this last month in the New York Times Magazine, when I profiled Ambient Devices, a incredibly cool Cambridge-based company, who are pioneering the idea of "ambient information." They've created a small glass Orb that changes color to match information you want to monitor:
The orb sits on your office desk and glows a quiet yellow. To a visitor, it might appear to be a slightly fey designer lamp, or perhaps a mutant night light. In reality, it's a financial tool: the orb changes colors to track the performance of your stocks. When the market is stable, it glows yellow; when stocks are soaring, it becomes increasingly green. And if it begins to fade into a deep scarlet? Better call your broker.
This is ''ambient information'' -- the newest concept in how to monitor everyday data. Normally, our digital tools are intrusive, constantly barging in to demand our attention with e-mail alerts, beeping instant messages and phone calls. The Ambient Orb, released this year by Ambient Devices, takes a different approach. It displays information that you take in subconsciously. Instead of blasting the news at you directly, it radiates it in the background.
''The point is, you don't need to keep checking into CNNfn all day long like a neurotic freak,'' says David Rose, the C.E.O. of Ambient Devices. ''You know implicitly what's going on, because the information is all around you.''
If Apple is creating an Orb-like enclosure for the computer itself, that would be an extremely cool thing. On the other hand, it wouldn't shock me if it infringes on the patents of Ambient Devices -- so there we may be in for a big patent battle here.
(Note: I went to the U.S. patent web site but couldn't find the listing of the patent itself, to point to the pictures. Can anyone find it?)
Posted by Clive Thompson at January 06, 2003 01:43 PM
| TrackBack
I really did think that the concept of Ambient information was one of the most profound in that NY Times magazine. There has to be some commonality of the patents between Apple, Ambient Devices, and the lighting company.. but I imagine that'll be hashed out.
Another area that seems to be indirectly converging is this idea of information with us all the time. Ambient Devices is a great example of that, and then Microsoft recently announced their Spot initiative. Although it certainly isn't a light, they seem pretty related in concept. I wonder how much their future vision competes? I did see a watch on the Ambient website.
If Ambient is going to be facing Microsoft, I'd suggest partnering with Apple asap.
Heh. Yes, I suspect partnering with Apple is a good idea for Ambient, though who knows? If their patents precede both Apple and Microsoft, maybe they can make all their money on licensing.
I'd buy an ambient glode, if it would work here in the UK.
This is a device/app waiting for a consumer wlan interface, if you ask me. For a start, delivering information via a radio paging network limits the market to the coverage area of the paging network- more impartantly if I were to spend $150 on an intelligent ornament I wouldn't want to commit myself to an monthly fee just to make it work properly.
A configurable device runnig on 802.x or Bluetooth would be very different- change the input and formatting info to whatever you want, not just what the manufacturer makes available.
I totally agree. I think the globe is itself fairly customizable -- but the info still has to travel over the radio/pager network. Being able to run it on a personal, local wireless link would rock much more.
well, wifi would rock for the 10% of the market that actually has a local wireless network. but if you are trying to create a broadly applicable product, then certainly radio/pager networks are a better choice for the forseeable future. certainly covering 90% of the us market is much better than 10%.
btw - the devices work in broadcast mode, no service fee. you only pay service fees for premium information, otherwise no monthly fee at all. that said, they need to release a version in the UK
link to patent app, it takes a while for these apps to be posted
If Ambient is going to be facing Microsoft, I'd suggest partnering with Apple asap.
We can see an example of this in our code we've written so far. In each function's block, we declare variables that hold our data. When each function ends, the variables within are disposed of, and the space they were using is given back to the computer to use. The variables live in the blocks of conditionals and loops we write, but they don't cascade into functions we call, because those aren't sub-blocks, but different sections of code entirely. Every variable we've written has a well-defined lifetime of one function.
The Stack is just what it sounds like: a tower of things that starts at the bottom and builds upward as it goes. In our case, the things in the stack are called "Stack Frames" or just "frames". We start with one stack frame at the very bottom, and we build up from there.
When a variable is finished with it's work, it does not go into retirement, and it is never mentioned again. Variables simply cease to exist, and the thirty-two bits of data that they held is released, so that some other variable may later use them.
Our next line looks familiar, except it starts with an asterisk. Again, we're using the star operator, and noting that this variable we're working with is a pointer. If we didn't, the computer would try to put the results of the right hand side of this statement (which evaluates to 6) into the pointer, overriding the value we need in the pointer, which is an address. This way, the computer knows to put the data not in the pointer, but into the place the pointer points to, which is in the Heap. So after this line, our int is living happily in the Heap, storing a value of 6, and our pointer tells us where that data is living.
This back and forth is an important concept to understand in C programming, especially on the Mac's RISC architecture. Almost every variable you work with can be represented in 32 bits of memory: thirty-two 1s and 0s define the data that a simple variable can hold. There are exceptions, like on the new 64-bit G5s and in the 128-bit world of AltiVec
When a variable is finished with it's work, it does not go into retirement, and it is never mentioned again. Variables simply cease to exist, and the thirty-two bits of data that they held is released, so that some other variable may later use them.
Each Stack Frame represents a function. The bottom frame is always the main function, and the frames above it are the other functions that main calls. At any given time, the stack can show you the path your code has taken to get to where it is. The top frame represents the function the code is currently executing, and the frame below it is the function that called the current function, and the frame below that represents the function that called the function that called the current function, and so on all the way down to main, which is the starting point of any C program.
Since the Heap has no definite rules as to where it will create space for you, there must be some way of figuring out where your new space is. And the answer is, simply enough, addressing. When you create new space in the heap to hold your data, you get back an address that tells you where your new space is, so your bits can move in. This address is called a Pointer, and it's really just a hexadecimal number that points to a location in the heap. Since it's really just a number, it can be stored quite nicely into a variable.
Note first that favoriteNumbers type changed. Instead of our familiar int, we're now using int*. The asterisk here is an operator, which is often called the "star operator". You will remember that we also use an asterisk as a sign for multiplication. The positioning of the asterisk changes its meaning. This operator effectively means "this is a pointer". Here it says that favoriteNumber will be not an int but a pointer to an int. And instead of simply going on to say what we're putting in that int, we have to take an extra step and create the space, which is what does. This function takes an argument that specifies how much space you need and then returns a pointer to that space. We've passed it the result of another function, , which we pass int, a type. In reality, is a macro, but for now we don't have to care: all we need to know is that it tells us the size of whatever we gave it, in this case an int. So when is done, it gives us an address in the heap where we can put an integer. It is important to remember that the data is stored in the heap, while the address of that data is stored in a pointer on the stack.
We can see an example of this in our code we've written so far. In each function's block, we declare variables that hold our data. When each function ends, the variables within are disposed of, and the space they were using is given back to the computer to use. The variables live in the blocks of conditionals and loops we write, but they don't cascade into functions we call, because those aren't sub-blocks, but different sections of code entirely. Every variable we've written has a well-defined lifetime of one function.
WHO CARES ASSCLOWNS..DONT WASTE TIME POSTING CRAP..JUST GO SEE SOME GOOD PORN
Hello folks nice blog youre running
