Dubroy.com/blog

The Interactive Telecommuncations Program (ITP) at NYU is a graduate program where students from diverse backgrounds get together to do cool stuff with technology. Every semester, they present an exhibition of student work — “interactive sight, sound and physical objects from the student artists of ITP”. Since I’m interested in the program, I decided on a bit of a whim to head down for the ITP Winter Show 2006.

Phillip Torrone posted a ton of photos from the show on the MAKE blog, but I thought I’d highlight a few of my favourite pieces.

From my point of view, one of the coolest things in the show was Botanicalls. Botanicalls allows you to have a phone conversation with your plant — it will call to tell you when it is thirsty, and again to say thanks after you have watered it.

Right beside the Botanicalls display was Andrew Schneider with his perform-o-shoes. These “wireless sensor-embedded kicks” use the motion of your feet to control a piece of music. When I heard Michael Jackson’s “Bad” from across the room, I had to go take a look, and I wasn’t disappointed. Be sure to check out the video.

After checking out Andrew’s shoes, I was drawn to the other thing making weird sounds in the room: Roy Vanegas’ MIDI pick. It’s a pressure-sensitive guitar pick that functions as a MIDI controller.

There were a few interesting projects under the theme of Sustainability. One of them was The Garden Electric, which uses wilting plants to bring attention to your electricity usage. Being bike-obsessed, I’m not sure how I managed to miss BikeJuice, which was right beside The Garden Electric.

The Smart Shelf is a bookshelf that can detect when a book is removed from the shelf. There were two interesting applications of this at the show. First, at a bookstore or library, it could be used to give recommendations of other books to read. The second application was for home use. When a child takes a book off the shelf, it would trigger a phone call to the child from one of the characters in the book.

All in all, it was a very interesting show, and I’m glad I made the trip. If you’re interested, you can see the full list of projects on the ITP site.

On Creating Passionate Users, Kathy wrote a great article about telling your inner voice to shut up. After reading the article, I went to play a soccer game, and played what was easily my best game of the indoor season. During the game, I did things that I would never have thought I could do. As Kathy says, it’s amazing what you can achieve when you don’t let the logical side of your brain get in the way.

Afterwards, I started thinking about that sweet spot between humility and confidence. It happens when you are confident enough that you slightly overestimate your abilities, driving you to do succeed at things that you couldn’t before; but humble enough that you avoid those really stupid mistakes. I think the confidence comes from the emotion part of your brain — basically, your ego; and the humility comes from the logical part. So to find the sweet spot, you need to shut the logical part up just enough.

Over at Signal vs. Noise, Matt talks about taming the RSS beast:

Is keeping up with RSS feeds a challenge for you? If so, what solution would you like to see? Are there blogs or software tools out there that are already doing some/all of the above well? Let’s hear about it.

I probably subscribe to fewer RSS feeds than most people — I’ve got 16 in there right now, and less than half of those publish even a post per day. And still, I find it to be an annoyance sometimes. It’s just oh so compelling to click on those Bold Headlines (56).

In the comments to the SvN article, several people suggest that you should only subscribe to feeds that you can’t miss, and the rest you should keep as bookmarks in your browser. What if I don’t keep bookmarks in my browser? I work on several different computers during the day, and one of the things I love about subscribing to RSS feeds in Bloglines is that everything I want to read is in one place, and accessible from any computer.

Jeff raises a good point:

I don’t have any answer, but this post got me wondering: is there really a fundamental difference between managing your RSS feeds versus managing your email inbox. Of course there are differences, but basically you just need a way to prioritize and quickly evaluate what you want/need to deal with now versus later. How do you manage your inbox? Why can’t you use a similar approach to feeds?

This is something I’ve been thinking about for a long time. We deal with all kinds of information on a daily basis, in many different formats: email, blog postings, rss feeds, documents, bookmarks, etc. Each one of these formats has is managed by a different application, each one with its own features and quirks. Every application you have to be familiar with adds a little bit more to your cognitive load. Why do we insist on segregating our data based on its format? Couldn’t a single application be able to deal with different data formats?

This is something I will be writing about a lot more on this blog — the problems with current information managment software, and what can be done to fix them. Stay tuned.

These days, it seems like most people feel they can be more productive in a dynamic language, like Python or Ruby. In general, I feel the same way, but sometimes I do miss static typing. What I specifically miss is being able to look at a method and have some clue what the parameters are.

Take this (totally contrived) example, in Python:

def reportEvent(dest, event):
    if dest.isStarted():
        dest.print(event)

And similar code in Java:

void reportEvent(ErrorLog dest, Event event) {
    if (dest.isStarted()) {
        dest.print(event)
    }
}

When you look at the Java example, you immediately have a better idea what is going on. In my experience (having worked on a large Smalltalk project), you will lose a lot of time in a dynamic language trying to figure out code just like this. And Stephan Schmidt raised another good point that autocompletion is much more difficult in dynamically-typed languages.

I think there’s a way to get the best of both worlds, and I’m surprised I’ve never heard anyone mention it before. Whenever you run the application, the runtime could take note of the type of each parameter, and then later feed that information to the IDE. If you’ve run the method 1000 times and the parameter has been a String each time, then you can pretty safely say that the parameter is a String. If it’s a Dog half the time, and a Cat the other half, then the type is Animal.

I don’t see why this would be especially hard to implement. Yes, it would require a higher level of integration between the IDE and runtime than we are currently used to, but it seems like it could be a real time-saver.