Noodlings

Just found out this weekend, somewhat belatedly, that my talk at NSConference 6, “Life Outside the Mac App Store”, is available on Vimeo. I don’t have the nerve to watch it myself but given recent events, you might find it interesting.

It’s nice to see Hazel in books. Even in digital form, the book format gives me more of a sense of permanency than say articles on some site. So, when I see Hazel mentioned in a book, I can’t help but think of Hazel as being a more permanent fixture in people’s computing lives. The most recent entry is Joe Kissel’s book “Take Control of Automating Your Mac” which has a little section talking about Hazel. While most readers of this blog are already familiar with Hazel and Mac automation in general, this book is a great introduction for the novice in your life who is ready to delve deeper into their Mac. It also contains coupons for many of the apps mentioned in the book.

And on the topic of Hazel in books, I’m way overdue in mentioning “Mac At Work” by David Sparks. This came out a while back but is a great intro to using your Mac in a work environment. Also, it’s available as a physical book, which is always useful for propping up an uneven couch leg (after you’ve read it, of course).

I’m still waiting for Hazel to be incorporated into some work of fiction. Too bad Stieg Larsson isn’t around anymore as he had a tendency to go into way too much detail about characters’ computer configurations.

With OS X Yosemite going public beta, I feel that it’s important that people understand what that entails. This happens almost every year but it seems worthy of a reminder.

Beta is the development phase where the product is not finished but ready to be tested. Operative term: NOT FINISHED. What does this mean to you?

• There Will Be Bugs
• Many apps will not work.
• Things may be slow.
• You may lose data.
• Issues will be addressed on the developer’s schedule, not yours. Even until some time after Yosemite is released, apps may not be ready yet.

In short, if you use your machine for any type of important work, DO NOT INSTALL THE BETA. It’s not our, or Apple’s, fault or responsibility if you are unable to get anything done because you didn’t heed this advice. If you must install it, in the very least install it on another drive/partition or virtual machine (VMware, Parallels, etc.) so it doesn’t impact your main installation.

And remember the purpose of the beta is for the developer to test their product, not for you to get a sneak peek at what’s new. If you find a bug, report it to the developer. And I mean REPORT it. Do not instead:

• Talk about the bug on some site that the developer will not see.
• Review an app running on a beta OS or is in beta itself.
• Tweet a complaint with few details (Twitter is horrible for bug reporting).
• Stay quiet about it and assume the bug will be magically fixed.

If you really care about the bug getting fixed, then tell the developer directly, providing necessary details. If possible try and figure out if the bug is Apple’s or ours and email the appropriate party. In general, during the early beta stages, the bug is probably Apple’s. Near the end, it’s probably ours. We do want to fix things but not reporting them properly is counterproductive to that.

With everyone’s cooperation, hopefully the transition to Yosemite will be a smooth one. Ok, maybe not, but at least I tried.

In Hazel 3.1, I added the ability to upload files. Underneath the hood, I used ConnectionKit 2 to do the heavy lifting. It has an API similar to NSFileManager, making it very easy to add FTP, SFTP and WebDAV support without having to deal with the pesky details of those protocols. There were other factors on why I chose it, such as the fact that not only is it actively developed, but done so by people who use it in their own shipping commercial products. And it didn’t hurt that it’s maintained by my friends at Karelia.

If you have used this feature in Hazel, you would have encountered this interface:

It should look a bit familiar. It’s a homegrown, from scratch, implementation of NSOpenPanel made to work on top of ConnectionKit. I felt it important to provide a familiar interface instead of coming up with something new in this case. I did a bit of work to make sure it operated as closely to NSOpenPanel as was reasonable. It has multiple view types (icon, list, and column) and most of the controls you’d expect.

Of course, browsing a filesystem via various network protocols is a different beast so some things had to be done differently. The main thing is that the UI is asynchronous from the network stuff so no beachballing while waiting for responses from the server. The UI should be responsive at all times, even allowing you to cancel the panel at any point. In the upper right, there’s a reload button that changes to a progress indicator to indicate activity and you will see a loading message when trying to fetch the contents of directories that haven’t been loaded yet.

Visually, the biggest difference is the header up top noting which server is being browsed. Also, the sidebar is missing. There aren’t many standard locations that can be put there and I felt that favorite URLs should be managed elsewhere as it didn’t seem likely that users would want to hop from server to server by clicking different entries in the sidebar. The one common directory that I could think of was the home directory and so instead, I gave that its own button (note that not all servers/protocols have such a concept of a home directory and it also depends on what URL you use to connect to the server so YMMV).

Another omission is the search field. Since there’s no notion of Spotlight in any of these protocols, doing an exhaustive search of the remote filesystem would be resource intensive and not very friendly to the servers involved. While I may consider adding it back in to search the current directory, you can get much of the same effect by just typing out the name of the file. Just as in NSOpenPanel, it will end up selecting the entry starting with those characters. I also dropped the Arrange button and the Coverflow view, mainly because I didn’t think people actually used those things. Especially for Coverflow, it wouldn’t be particularly useful since we can’t get file previews without downloading the whole files themselves.

But besides all of that, I think you’ll find it to be a pretty decent facsimile of NSOpenPanel. You might be surprised by how much of NSOpenPanel’s behavior is replicated here, including some features many people don’t know that NSOpenPanel has.

And the resemblance is more than skin deep. CK2OpenPanel (the name of the NSOpenPanel implementation) has a nearly identical API to that of NSOpenPanel. It’s a mostly drop-in replacement for NSOpenPanel so programming to its API should be just as familiar. Why would you care? Well, you should care because I’ve contributed the code for CK2OpenPanel to be included in ConnectionKit. You can see all the code, warts and all. Play around with it. Use it in your own projects. Print it out and wallpaper your home with it. I felt it was the least I could do for all the work that’s been done on the backend. Also, I thought it would be nice if people adopted it so that there was a standard UI for this type of thing.

You can find everything on the ConnectionKit GitHub page. In particular, you want to check out the v2.x-beta branch. Note that there are separate targets/frameworks in the project for the back end (ConnectionKit) and front end (ConnectionKitUI), with the latter dependent on the former. Make sure to check out the README as it should answer a lot of your questions. And if you are interested in contributing to ConnectionKit, please do as there are a bunch of things that need work. S3 support would be nice, for instance.

Last but not least, a big thanks to Mike Abdullah at Karelia for working with me to provide the backend support for this. Rest assured that he will be receiving beers from me at the next conference we both attend.

Enjoy.

Fresh from the Noodlesoft Danger Labs is Hazel 3.1 with a bunch of spiffy new things. The two main features this time around are file uploading and matching against file contents. If you don’t use Hazel, maybe these sound a bit abstract to you but for people that use it, it fills a couple big holes in their workflows.

But instead of elaborating on these myself, I’ve been fortunate to have a couple users do the work for me. Demonstrating use of the new file upload facility, Sid O’Neill shows his workflow for resizing and uploading images to his server. 

Next up is David Sparks (MacSparky and MacPowerUsers Podcast) showing how to match and extract dates out of your files and use them for renaming. Includes a great video so definitely check it out.

Of course, there are a bunch of other things in this release. You can find the full list here.

The response from customers have been great. I’ve gotten a lot of wonderful emails from people so far which has solidified my dedication to the product even more. As mentioned in my last post, I will be looking into Mavericks support, with a particular interest in its tagging feature, in a future release.

Also, in regards to the new upload feature, watch this space in the coming weeks as I’ll have something for you developers.

Actually, this is probably old news since this happened last Thursday, but I finally released Hazel 3. For those of you who don’t know what I do for a living might want to check it out. If anything, you’ll understand a good part of the reason why I haven’t posted here much in the past year or so.

To say I’ve been busy is an understatement but it seems the launch was a success. Ok, so the store was not quite working for the first hour and even after I got it up, there were all sorts of glitches. And nevermind that the links in one of my emails was wrong resulting in thousands of people emailing me asking me about it. And overlook the fact that there were quite a few instabilities in Hazel for people running on 32-bit that were missed in the beta. And it wasn’t all that fun when my bank froze my corporate debit card because it thought that all the charges I was making that day were possibly fraudulent. I can ignore all that because a bunch of people actually bought the result of my hard work and for that, I say thank you.

And also, as a heads up, I will be splitting this blog at some point in the not-too-distant future. I will be starting up a Noodlesoft/Hazel specific blog targeted towards my users which will have tutorials, tips and news while keeping Noodlings as my blog for much more developer oriented stuff. Keep your eyes posted here for updates on that.

After all the delays, dead ends, procrastination, wool gathering, futzing around and some actual hard work, Hazel 3 is finally open for beta testing. There’s no set duration for the beta period; it ships when it’s done.

If you’re feeling lucky, you can get the details from this forum article (you need to register for a forum account if you haven’t already). By the way, I hear Time Machine is pretty cool.

Five years ago today, I shipped Hazel 1.0.

Hazel started as a personal project that I wrote for my own use but over time I realized that this might be useful to others. Sometimes you just have to dive in. I quit my job to work on Hazel full-time and some months later, I finally shipped my 1.0. Sales were modest at first but over the years it’s paid off. It was a lot of work but it was worth it. If anything, I’ve clocked in more hours over the past few years working pantsless in my home office than over my entire career previous in various other offices.

This blog has been quiet for a while mainly because I’m still at it. Hazel 3 is nearing the testing stage (expect a beta release and more details soon). It’s a bit overdue; I was hoping to release before Duke Nukem Forever but then again, they had bit of a head start. With each new version, I feel like Hazel is fulfilling the vision I had when I first released it five years ago, and then some. Of course, I could never predict the new and interesting ways you have used Hazel over the years and hopefully you, the users, will help shape the product for many years to come.

Enough about the future. It’s Hazel’s birthday today and in celebration, you can get 20% off until midnight tonight (Tues, Sep. 6, Eastern time). Just use this link. Most of you reading this probably have a copy already but I’m sure you have a friend/relative/corporation with deep pockets that could use a copy (or twenty) so send the link along to them. Or buy an extra copy for yourself because you’re just crazy like that. And while you’re at it, have a drink on Hazel’s behalf, or even better, have a drink (or five) before you hit that order page. I hear you save more money have more fun that way.

I was just turned on to a post from Jesper of Waffle Software entitled How to Mimic the Artwork Column in Cocoa. There he approaches the problem of implementing cells in an NSTableView that can span multiple rows. This spurred on Jacob Xiao at Like Thought to tackle the problem in a different manner. I suggest reading both of the above to get a sense of the problem and the possible approaches.

With NSTableView still on my mind from my last diversion, this got me thinking about the problem and I decided to try my own hand at it. I preferred Jacob’s approach as I think it should be all contained within NSTableView if at all possible. I liked the notion of “slicing” up the cell instead of using another view. Playing with it, I came up with a generalized solution. Here are some of the interesting aspects:

• It can support any NSCell subclass. I do this by using a special wrapper cell. It draws the “full” version of the cell then draws out the slices for each row into the tableview.
• It determines the spans by finding contiguous rows that have the same object value for the column in question.
• The above two points are exploited to do some caching such that the “full” cell is only drawn once and the parts composited in place as needed.
• If the first column is set to span rows, it will only draw the grid for the last row in a span.
• You can designate multiple columns to do this. In the example project, if you click on the “Album” column, it will toggle between span and non-span mode. The “Artwork” column doesn’t do this because it looks cruddy in non-span mode. I haven’t tested it (see update below) but theoretically, the spans do not have to line up between different columns.

To use it, for any columns you want to have this row-spanning behavior, set the table column class to NoodleRowSpanningTableColumn. Also, it might help to get rid of any intercell spacing in your tableview (at least in the vertical direction). There are probably a few bugs. I do know that reordering columns may cause some grid drawing funniness but for the most part, it seems to work pretty well. Let me know if you find otherwise.

You can check the code for other implementation tidbits. I’ve included a self-contained project below but I’ll eventually polish it a bit and add it to my NoodleKit repository where it can join the rest of my goodies.

Many thanks for Jesper and Jacob for the inspiration and laying down the groundwork for this.

Update (Oct. 21, 2009): I observed odd behavior in that the program would get into a re-drawing frenzy eating up a bit of CPU. This was non-blocking in that I was still able to manipulate the UI (which is why I didn’t notice it at first). I finally figured out that it was the -drawGridInClipRect implementation. I was drawing the grid selectively by changing the grid mask and then calling super on subregions. Unfortunately, changing the grid mask queued up a redraw which started a loop (albeit one that didn’t tie up the event loop). Seeing as I needed to fix the grid-drawing logic anyways, I reworked the whole thing.

The new grid code should now be able to handle multiple spanning columns rearranged in whatever way you want. Here’s contrived example of having multiple spanning columns that don’t necessarily line up:

I also made some other fixes and improvements so it’s worth re-downloading the project even if you already did so before (I bumped this version to 0.37).

As for integration with the rest of NoodleKit, I still need to decide whether I want to merge this with my sticky row tableview to make some über-tableview. Problem is is that I can’t think of how the two features would interact so maybe it’s best to keep them separate. Thoughts on this are welcome.

Update (Oct. 23, 2009): I’ve just updated the project to version 0.68. There was a crasher when you would click on a non-span row and then move into a spanning cell. Also, the span cells were highlighting when you clicked on a non-span row. Both of these have been fixed. Thanks for Jesper for finding the crasher and Jacob for helping with the fix.

Update (Oct. 25, 2009): I’ve consolidated this functionality along with my previous sticky row header code into a single NoodleTableView class. You can find it in the NoodleKit repository. Future updates to this will be posted there from here on out.

Download NoodleRowSpanningTableViewTest.zip
[This project is no longer being updated here. You can get the latest in the NoodleKit repo]

Seems like forever since I’ve done a release. There have been odd setbacks here and there but Hazel 2.3 is out at last.

For those that share your machine with others, you’ll find that the App Sweep feature now allows everyone on a machine to have their support files thrown away when someone throws away an app. Everyone that wants to participate has to enable the feature (look in the “Trash” pane). I would have made this not an option but I had visions of people complaining about others being able to see what apps they are throwing away. So, now there’s a checkbox which personally I’d rather not have.

The feature I’m most excited about is, of course, the one that most of my users probably won’t care about or notice. But, this being a developer blog, I’m sure some of you would be interested. In version 2.2, I added an embedded script editor. The AppleScript editor had syntax highlighting because, well, Apple gives that to you. In 2.3, I’ve added syntax highlighting to the regular shell script editor. Of course, it’s not just for shell scripts. Just set the interpreter you want and if it’s one that Hazel knows about (currently, it’s bash, Perl, Python, Ruby and awk), then Hazel will color your code appropriately. Give it a spin and let me know what you think.

Oh, and I didn’t add any UI to configure the highlight colors. If you really hate the color scheme it uses, you can take your XCode color theme and copy/symbolically link it as ~/Library/Application Support/Hazel/Hazel.xccolortheme. I thought about making Hazel just use whatever is set in XCode but I got the feeling that people weren’t using XCode to edit their non-Objective-C stuff. I may change my mind on this in a future release. Feedback welcome.

And of course, there are a bunch of other new features, improvements, and fixes (and probably bugs).

As for the roadmap, there will definitely be another (free) update of some sort before 3.0. Snow Leopard is coming out in a couple months and I need to make Hazel compatible. If you are running Snow Leopard and would like to test, definitely drop me a line.