NilObject

First, let me get to the nitty gritty for those who are here for the plugin and not my experiences. Today I’m pleased to announce that in a joint effort with Todoist.com, a Quicksilver module is available for download.

Why in the world would I care?

It may very well be that you don’t care, and perhaps you shouldn’t. Perhaps you’re the type of person who never has any problems remembering to do something. However, if you’re like me, keeping organized and remembering what needs to get done and when both at home, the office, or wherever is always a battle.

A couple years ago, I read the book Getting Things Done: The Art of Stress-Free Productivity, and I immediately “got it.” But I didn’t have a mechanism to organize things that I could stick with.

I began writing my own application, using others, etc., but recently I stumbled upon Todoist which solves the problem in a very simple and elegant way. It’s not exactly a purist implementation of the GTD philosophy, but it is easy to use and powerful enough for my needs.

But I still couldn’t get used to it — it required a visit to the site, clicking on the project I wanted to add the item to, and then adding it. It should be simpler.

Enter Quicksilver. I tried using Quicksilver a year or two ago, but it never quite caught on with me. After recently encountering QuickSilver - A Better OS X In Just 10 Minutes I downloaded it again and began using it in my regular workflow. Putting two and two together, I knew I should write a Quicksilver module for Todoist.

I emailed the developer, and heard back very quickly. With him designing an API, I wrote up a module this weekend. I’m proud to show it off here. It’s pretty simple to use. Edit: There is now a Quicksilver integration guide on the Info page in Todoist.

The usage is pretty straightforward if you’re a seasoned Quicksilver user. If you’re just beginning, bring up Quicksilver’s window using the keyboard shortcut assigned in the preferences. Type a period (”.”). This switches Quicksilver into text entry mode instead of searching mode. Type in the item you want to add to Todoist. When you’re done, press Tab.

Now, find “Add Todoist item to…”. This usually can be done by simply typing “add”. Once selected, press Tab again.

Lastly, either type in the name of the project you want to add this item to or simply use the arrow keys to navigate the list. When complete, press Return. You’ve just added an item to Todoist.

For me, this is the last key in my puzzle for searching for an easy way to remain productive, but still be able to quickly note things as they come up.

Not working right or want something added?

This plugin is a work in progress, mainly with the graphical aspects. Not being a designer myself, I’m doing the best I can. Any bugs or feature requests for this module should be sent to me and not to the fine folks at Todoist.

Good luck, and happy lifehacking.

Since posting this, a few bug fixes have been made. The current version for download is “A0″. If you have an earlier version, please download the latest version.

27 Comments »

So, yesterday REALbasic 2007 Release 2 was released, and I can finally say what I’ve been wanting to say for 3 months now: REALbasic 2007 release 2 was developed in REALbasic 2007 release 1. Additionally, this past week and a half or so, I was using REALbasic 2007 release 2 to fix bugs in REALbasic 2007 release 2, ensuring that everything is working for us internally, as well as giving release 2 some good real-world usage.

And boy, I must say, incremental compilation is *nice*. I have two machines I use for development, my personal MacBook with 2 GB of ram, and a 24-inch iMac also with 2GB of ram. The IDE project is quite large, but with 2 gigs of ram, I didn’t really page-out much in release 1 when compiling. However, it was a huge speedup compared to running our internal mutant version of 5.5 in Rosetta. The IDE compile speeds clocked in at around 34 seconds for me.

Switching to Release 2, the compile speed is down to 31 seconds for the first run, but wow… when fixing bugs I often experience under 10 second compilation times because of the new incremental compiler.

What else is new? Aaron did an incredible job with adding tons of new features to the debugger. Most of them restore functionality that was lost in the 5.5->2005 transition, but some of the functionality added is stuff we’ve been wishing we could do for a very long time. Take for example string viewing. Now you can see the binary contents of the string, view the string in different encodings, and even set the encoding right in the debugger! Debugging encoding issues couldn’t be easier now.

What did I add? Well, I fixed a ton of bugs. Unfortunately, one of the biggest bug fixes came towards the end of the cycle when 10.4.9 was released. There was a bug with KeyDown events being fired twice if they were unhandled, and the proper fix was to update some really old code. How old? Old in terms that it was originally written back in the System 7.5 days. It’s always been working, so there hasn’t been a pressing need to update it. Until now, that is.

Of course, updating it caused a lot of ill effects, such as default buttons no longer working (turns out *that* code was ancient too). All said, the 10.4.9 update put a lot of stress on the final builds, but I think we only let one new bug out relating to these large changes.

And I also added Code Folding. But it’s not really that big of a deal — I wanted a break from my other projects on a Friday afternoon, and walah, a few hours later we had code folding. It works on the same system that indentation works, which is why it has a few “but I want it to work *that* way, not this way!” moments. The rule is very simple: any block start that has a match below can be folded, and the code between the block start and the match below will be hidden when folded. For example:

If True Then
  // this comment will disappear
End If

In this situation, a little widget will appear next to “if true then” that can be clicked on. When folded, the “this comment will disappear” line will be hidden. While simple and elegant, it has a strangeness when dealing with Select Case blocks:

Select Case foo
Case bar
  // This is a child of the "case bar" statement
Case baz
  // This is a child of the "case baz" statement
End Select

A folding widget appears next to Select Case foo. Since there aren’t any lines between Select Case and the first Case statement (although it is legal to put comments there), it would seem intuitive that clicking the folding widget would fold something. However, because the rule is very simple and elegant in its implementation, it has no special cases at the moment. This isn’t necessarily how this feature will remain for years to come. We wanted to get some real world usage before rewriting it, only to rewrite it again, ad infinum. Unlike many other languages, REALbasic has a pretty complicated grammar defining what starts and ends a block.

All in all, I’m pleased with the result of Release 2. It’s bound to have a few new bugs due to some of the larger changes that took place. But for the most part, it’s working quite well for us internally, and so far it appears to be working pretty well externally as well. As usual, please file any bugs that you find are new to 2007 Release 2 as soon as you find them. We have a special fondness for new issues — we like to squash them as soon as possible.

Good luck, and enjoy!

8 Comments »

Well as most of you found out, 2007 Release 2 was released today. Due to some longer hours pulled last week, and even into the weekend, I took today off to relax. That means Cocoa got to play a lot today, and I took a nap (a rare experience — I only take naps when I’m *really* tired). I’ll post a formal update about that tomorrow.

I’ve been listening to the book iWoz in which Steve Wozniak, cofounder of Apple, describes his experiences, pranks, and projects that influenced him starting from even an early age throughout his life as an engineer. It’s a great book, and I just finished it. What I wasn’t expecting was the conclusion to the book. I would love to quote the entire thing, but I’ll settle for a smaller nugget that I felt really identified what I feel writing code is like. My apologies in advance to Steve and his publisher, because I’m sure the punctuation doesn’t match. But hey, I transcribed from the audiobook

Why do I say that engineers are like artists? Engineers often strive to do things more perfectly than even they think is possible. Every tiny part or line of code has to have a reason, and the approach has to be direct, short, and fast. We build small software and hardware components and group them into larger ones. We know how to route electrons through resistors and transistors to make logic gates. We combine a few gates to make a register. We combine many registers to make an even larger one. We combine logic gates to make adders, and we combine adders to create others that can be used to create an entire computer. We write tiny bits of code to turn things on and off.

We build upon and build upon and build upon, just like a painter would with colors on a paintbrush, or a composer would with musical notes. And it’s this reach for perfection — this striving to put everything together so perfectly in a way no one has done before, that makes an engineer or anyone else a true artist. Most people don’t think of an engineer as an artist, probably, because people tend to associate engineers just with the things we create. But those things wouldn’t work, they wouldn’t be elegant, or beautiful, or anything else, without the engineer carefully thinking it out. Thinking how to create the best possible end result with the fewest number of components. That’s sophistication.

In my entire life I’ve only seen about one in twenty engineers who really exemplify that artistic perfection. So it’s pretty rare to make your engineering an art, but that’s how it should be done.

I was very touched recently by a scene in a movie called “Walk the Line.” In it, a producer tells Johnny Cash to play a song the way he would if that one song could save the whole world. That line summed up of what I look for when I talk about art — in engineering or in anything.

He goes on with further insight that really struck home with me. I thoroughly enjoyed the book, and with a conclusion like that it’s a truly inspirational book. It’s incredible to think back and realize the types of insights that were required in days before the personal computer industry was born. Additionally, he clears up some oft-cited Apple misconceptions that I never realized were incorrect. This book is a great read for anyone even remotely interested in computers, but definitely more-so for developers like us. While he does a great job of “dumbing” it down to reach a broader audience, it’s not done in a way that prevented me from enjoying it.

Comments Off