I got a Pi about a week ago. It arrived unexpectedly early -- the Farnell/Element 14 site said there was a 32 day lead time expected. I ordered it Monday and got it on Friday (delivered by Toll from Singapore!)
I'm very impressed so far. I haven't had any real problems getting everything up and running, and after getting the linux distro set-up pretty much how I like things, I thought I'd jump in the deep end and try to see how feasible it was to port an Arduino program that was running at about 5000 lines of code across to Pi linux. This app runs a SPI slave device and also does some GPIO manipulation, as well as providing an ethernet server.
My main motivation for porting the program up to an embedded linux device was because of the port limitations on Wiznet style devices. The W5100 allows only four active ports to be in use at at one time, for example. That greatly limits the usefulness of this particular app.
Another issue that wasn't going to be addressed while staying in the 8 bit world was that SSL would be quite useful. Connecting to many servers these days requires SSL, which is simply never going to be available on an Arduino class device.
So after a couple of days -- it's all working! (It's not supposed to be this easy.) The SPI ioctl interface works just fine. Manipulating GPIO pins works just fine (the pins are memory mapped, you get a pointer to the mapped section of memory and write your bits there).
I was a bit worried about emulating delay(), delayMicroseconds(), and millis(), but Linux usleep() works nicely for this app. Most of my timing is of the sort "delay for _at least_ this long", so if usleep(10) actually takes longer than 10 usecs (within reason), no biggie for this app.
Emulating millis() was done by using one of the many time interfaces that return time in millisecond resolution. (I think time() in unix returns milliseconds since 1-jan-1970, IIRC.)
A bit of futzing to get the socket code to work as I required (non-blocking calls, don't raise signals on broken pipes, etc.), but working on the networking side of it is now playing to a linux box's strengths. Mapping all the Serial lib stuff to standard printf (via macros and a writing a few wrapper functions) was a bit dull and tedious, but straightforward.
So I was aiming after the port to be able to compile the same source code for either an 8-bit Arduino or the 32-bit Pi using just a few simple #define config directives, and that's not been all that difficult at all. Having gcc/g++ as the underlying compiler on both platforms helped this considerably, no doubt. (BTW, I did all the editing and compilation on the Pi itself, logged in via ssh using PuTTY from laptop, rather than using a cross compiler tool chain. Emacs, bash and gcc -- I was in a comfortable place, amongst old friends.
No doubt in the medium or even short term I will be extending the program on the Pi to places where the Arduino really can't follow, but really, that's the whole point, in practical terms.
So anyway, it's all working, much simpler porting process than I was expecting, and overall I'm pretty impressed with the whole thing. Bang-for-buck, the Pi is a compelling deal. It does full Debian Linux (which is a distro I am already familiar with and like a lot anyway), but it also it does pin-level IO, making it an interesting hybrid. It's got Ethernet, SD card storage, and USB ready to go. Not to mention those graphics!
And, of course, the price point is amazing. Still hard to believe, actually. Honestly, I'm not sure where something like a 32-bit Arduino is going to fit in between the 8 bitters and 32-bit devices of this capability. The Pi has definitely got a place in my toolbox for now. Not sure about the Due (or its inevitable imitators), but we shall see.