I’m going to be moving tomorrow, so this machine is going to go down sometime later tonight, and will be back probably tomorrow night.

I can’t wait to get back to school

Python-EFL packages were uploaded to PyPI, making it possible to install with setuptool’s easy_install.

This release is actually what is in CVS SVN for some time now and is up to date with current EFL code base.

It would be amazing if we could find official Ubuntu packagers for EFL and Python-EFL (see launchpad #259098), we already have one guy working with Fedora, it’s already provided as an overlay for Gentoo, OpenEmbedded has it too, Debian has it in experimental (bit old, but it’s there) and we have some out-of-tree packages for this great distro. Of course Maemo packages are there thanks to Etrunko. If you are willing to package, please contact the developers, we can provide useful hints on which packages are higher priority so you don’t package marginal stuff.

I’ve also updated the Python-EFL API documentation (automatically generated with epydoc).

So! Today marks the official end of Summer of Code, at least as far as coding is concerned. Final evaluations are due to Google between noon today and noon on September 1st…

I’ve decided to call revision c2c3fccb856771bf56fe15ad7c7ff66cf67ed2d9 my reviewable commit; I’ve not yet tested the Ecore stuff (which has progressed much further in the last 24 hours) in a clean install of Mac OS X, but that (and a patch!) will come soon.

It’s been a lot of fun, for sure, and I learned a lot! Especially about Cocoa/CoreGraphics, and a bit about the EFL architecture and what it is the Enlightenment ‘team’ spends all of their time on I’m not leaving for good, but what with moving back to RPI on Wednesday, and the end of GSoC, etc., I’m probably going to be missing for a week at least.

So I’ll say… Nathan and Dan were both excellent mentors (I was sad to see Dan leave Enlightenment, what with his clearly rather rare knowledge of a significant portion of the EFL, but I quite much understand his decision, and hope he finds something excellent to devote his time to in the future), and I’m very glad I got to work with both of them (as well as the brief encounters I’ve had with other members of the team)!

And, to the project: there’s certainly a good bit of awesome stuff going on here; I just hope that everyone can hold it together long enough to bring all the pieces together into something as awesome as the overarching idea of E seems to be. Good luck with that, for sure, and if you ever want an ‘outside’ head, drop me a line!

I’ve started implementing Ecore events. Lots of keyboard events work, and mouse events appear to totally work. Pretty cool!

Keyboard stuff is a mess… I’m borrowing heavily from the ecore_sdl module in that regard, but… they’re missing a lot of characters. So, that’ll be tonight. Then to clean stuff up and send in an Ecore_Quartz patch. Ehh. I named it Ecore_Quartz. It’s more Ecore_Cocoa. Maybe I should change that??

Code is in Git. Including stuff to make test/orig/ecore work with Ecore_[Evas_]Quartz

So I made a little discovery in a 7 year old mailing list post yesterday, and found out how to create a fully-functional Cocoa app, without letting the default run loop take over permanently, and without embedding the executable in an application bundle. Here you go:

EDIT: OK Wordpress is being silly; obviously, put < > around the #import file

EDIT 2: Also, obviously, you need MainMenu.nib to be in the same folder as your executable.

EDIT 3: If you want to go NIBless, use NSBackingStoreBuffered, not the default NSBackingStoreRetained when creating your window!

// Build like so: gcc short.m -framework Cocoa
 
#import Cocoa/Cocoa.h
 
int main(int argc, char *argv[])
{
   [[NSAutoreleasePool alloc] init];
   [NSApplication sharedApplication];
 
   [[[NSNib alloc] initWithContentsOfURL:[NSURL URLWithString:@"MainMenu.nib"]] instantiateNibWithOwner:NSApp topLevelObjects:nil];
 
   ProcessSerialNumber psn = { 0, kCurrentProcess };
   TransformProcessType(&psn, kProcessTransformToForegroundApplication);
 
   [NSApp finishLaunching];
 
   while (1)
   {
      NSEvent *event = [NSApp nextEventMatchingMask:NSAnyEventMask untilDate:[NSDate dateWithTimeIntervalSinceNow:0.001] inMode:NSDefaultRunLoopMode dequeue:YES];
      if (event) [NSApp sendEvent:event];
   }
}

I know Summer of Code is wrapping up (Monday is the absolute-pencils-down date), but I’ve got more news!

Following last weekend’s advances (getting a Cocoa app up without a bundle and a NIB), I’ve restarted work on Ecore. After fighting a little bit more with Autotools (aargh!) to get Objective-C building successfully (which worked much more easily with Expedite).

After that, I dropped in some code from my Expedite engine, to set up Cocoa. And, as you can see, I was met with success! A tiny Ecore_Evas_Quartz test program, successfully running. No events, yet, but they should come within a day or so…

In any case, my biggest issue right now is I’m not entirely sure what to put in Ecore_Evas_Quartz, and what should go in Ecore_Quartz. Nathan suggested something like that Ecore_Quartz should provide functionality to talk to Quartz that Ecore_Evas_Quartz itself uses; I guess I’m still not entirely clear on what exactly should go where. So a lot of stuff is going in Ecore_Evas_Quartz right now, but I can move it out once I find out what’s really what. (probably by reading other people’s code, though if I’ve learned anything from this, it’s that that’s a bad idea *ahem*Evas_Cairo*ahem*).

Also — this code is up in Git. Not SVN, though, obviously.

On July 19th, Tim and I made food for ourselves, while Mom and Dad were at the neighbor’s house for dinner. We decided to make our own pizza which has apples, cheese, chicken and onions.

Our first adventure was to make a crust for the pizza. Now, we’re good at making pie crusts, but a pizza crust is a completely different thing. It turned out to be not as much trouble as people made it out to be, but trying to figure out how to cook it so that the crust didn’t burn, but the top bits got cooked enough was interesting.

Tim cooked the chicken (as always) and I cut up the apple and onions. We piled that on the semi-baked crust. Then we poured on the cheddar cheese and attempted to do the same with the pepper jack cheese. See, we couldn’t find any shredded pepper jack, or a bar of it. So we bought slices. And then we had to shred it. We tried to use the large grater, but that failed. So Tim used the spinning hand held cheese grater—which worked perfectly. With all of our ingredients on the top, we put the pizza in to cook for another 10 minutes. When it came out, it was just browning and smelled great.

The pizza was excellent. We cut it up in to 9 pieces, and had it for lunch the next day as well. It tasted great and was quite simple to make. The crust worked extremely well and the apple/cheese combination is really good.

We decided that, before Tim left to go back to school, we should make one more dinner. This time, on August 13th (almost a month after our last full meal), we decided to go all out—which means a table cloth, perfectly aligned settings and every course imaginable (except for soup…). We decided to make a chicken and pasta bake, which I have made before with some friends at the Ronald McDonald House. In addition to that, we found a recipe for a spinach salad with sesame dressing. To our meal, we added dinner rolls and a mint tea punch. For dessert, we decided on profiteroles, which are basically cream puffs with ice cream instead of cream.

We went shopping on the 12th, which is always an exciting adventure. We scouted out everything that we needed, except for lemon juice. We solved that issue by buying lemons and squeezing them ourselves. We even got to check ourselves out, which is always fun! I spent some time last night going through the recipes and organizing a timetable for when we should start each separate piece so that we could end up with a hot dinner at around 6:30.

Today, we started at 4:00 with the rolls, because they had to rise. We mixed all of the ingredients (yeast, milk, flour, eggs, salt, shortening and sugar) in half quantities, so that we only had 12 rolls. The next step was to knead the dough until it was smooth. That turned out to be the most exciting thing ever! Well, not really. We floured the cutting board and plopped the dough down. Then Tim set to work kneading. I poured (and I mean poured) flour onto the dough and his hands so that it would stop sticking. I can’t say that it worked too well. The dough was horribly sticky and messy, but we got it into the greased bowl and let it rise for an hour.

While we were waiting, I did the dishes and Tim took some pictures. Before we knew it, it was time to start the main dish. First, I cut up all of the vegetables and gave them to Tim to sauté. I continued to combine ingredients—the tomatoes and spices. Then, when the vegetables were done, we added those to the tomatoes. Tim went off to cook the chicken which I cut up, and I set the pasta to cook. Those all finished in about ten minutes, and they too were added to the vegetables. Everything was mixed well and poured into a 13×9 pan. I shredded the monterey jack cheese and poured it into the whipping cream, while Tim measured the grated parmesan. All of that cooked over medium heat until it was a sauce. That was poured over the chicken/pasta/vegetable mixture. Then, we put into the oven to bake for 45 minutes.

With that done, we moved back to the rolls. They had to be split into 12 pieces and put on a pan. I floured my hands and dove into the dough. Eventually, with a lot of flour, the dough became 12 very round rolls. We put them in the oven with the chicken and pasta so that they would both be ready at the same time.

Next came the drink. We boiled some water and put tea bags in it, as well as a bunch of mint sprigs. We let that steep, and then I took out the leaves and we added sugar and orange juice. We squeezed the three lemons and had exactly enough lemon juice to add. Then came the five cups of cold water. We put it in the fridge to cool, took out the chicken pasta bake and moved on to the salad.

I mixed the spinach and red onion together and started on the dressing. We cooked the sesame seeds and added the other ingredients (soy sauce, oil, salt, sugar and cider vinegar). Once it was boiling, which was quite dangerous, I poured it onto the salad and tossed it together.

Tim was pouring melted butter and garlic salt over each roll (at which point I burned two fingers on the pans…) and letting them cook for another few minutes. Once that was done, they were taken out of the oven and put in a basket. Tim set the table perfectly and then we put everything on it.

So, all of our food was done and on the table, and Mom was working her way through our mountain of dishes, but we were still waiting on Dad to get home from the neighbor’s house. When he finally got home, we started dinner.

Every bit of dinner was excellent. The chicken pasta bake tasted really good, and had a lot of different flavors. The drink had a lot of flavors as well, but they all seemed to work together perfectly. The rolls worked much better than expected. It all worked together quite well… but then there was dessert…

So, for dessert we attempted to make profiteroles, which are, apparently, as hard to make as is it to say their name. It’s really simple to make the batter and shape it on the trays, but once it’s cooked, they 1) don’t come off of the pan well and 2) don’t fill well with ice cream because a) they don’t cut in half and b) they fall apart. Basically, this was our first big… issue. I wouldn’t say it was a disaster because how can you go wrong with ice cream? But it wasn’t what it was supposed to be, which was very sad.

Besides dessert, this was a very successful day of cooking!

Last last summer, I inherited a set of old IBM PSLs from my physics teacher. In case you don’t keep up with your early-eighties home science labs, it’s a rather large beige box with all sorts of modules that you can plug in, which in turn plug in to sensors (light, temperature, sonar, etc.). It’s got a 25-pin serial interface, so it took a bit of … maneuvering … to get it attached even to my old PowerMac G4, or Robb’s desktop (the machine formerly known as cary3). Crazy, I know!

Way back before last Christmas, I wanted to get the PSL temperature probe, at the very least, working. A little bit of Python later, and it was working! (the manual had sample code for all sorts of things, and also detailed protocol and implementation documentation - try to get that from nVidia!)

I then wrote a little canvas-y viewer script, and left it running, polling the temperature in our room in Cary Hall every minute for approximately two and a half months. The final output is here:

You can pretty clearly tell when Robb and I weren’t at school (especially spring break, the really smooth wavy part near the beginning). It was cool at the time, just a cute little thing… I dunno!

Anyway. I put it back up, here at home.

I’ve recently been merging a few different music libraries together into my iTunes library on my laptop, so I was interested to see what sort of growth my library’s had, over time. I whipped up a quick Perl script (which you can grab yourself, here - though you’ll definitely have to modify it to work on Windows). I plotted the data from my library with Mathematica, and got this:

There’s now a cleaner-but-less-succinct Objective-C version, and its source. The built version (first link) will run and then just disappear, having created ‘music-chart.csv’ in your home directory, which is a CSV of: (UNIX date, iTunes Library Count) pairs. You can chart it with anything that can chart pairs… Mathematica works (ListLinePlot[Import["/Users/hortont/music-chart.csv"], PlotStyle->Thick]); Numbers might, but I’ve seen it do nasty things (you have to manually set minimum and maximum X values, or something…); gnuplot will definitely work…

Here’s a post I promised a long time ago. I was playing around with Lisp back in late June, and wrote a little brute-force n-body problem solver. I should note that when I say brute force, I mean most naïve solution possible – summing all of the forces, etc.

It seems this is one of the first things I write in a new language now… not sure why, it’s not exactly a very good test of any language; at least not this type of implementation.

After the Lisp bit, I wrote a little point viewer in Perl (with Perl::OpenGL). It’s not as pretty or fast as the one Radiohead used that was implemented in Processing, but this was before that was announced, and I’ve never (yet) written anything in Wiring/Processing, so I wouldn’t have thought to use it.

So; it’s all really very slow, and silly. Very. Very. Slow. But, it works. Also, it’s physically inaccurate, in order to get results in any reasonable number of frames. Like, G is seven orders of magnitude larger than normal. So much for gravity being the weakest fundamental force… (EDIT: actually no. it’s still not even close.)

So, for your particle-simulating-pleasure: the Lisp and the Perl.

About 6 years ago or so I got tired of fixing problem with Tamarah Windows/Linux box and decided to pay the money for a 15" PowerBook. It was an excellent investment, she could work on the couch, no more lockups and reboots in Windows or mysterious "Bennnnnnn!" problems in Linux. Since then she's upgraded to a black MacBook, and when I joined Joyent they provided me with a MacBook Pro (which I'm typing on now). So far each of these 3 laptops has lost at least one drive. Since we've fallen in love with iTunes and iPhoto these drive failures have been a major blow, and prior to Leopard's TimeMachine we didn't do regular backups.

This post will refer solely to drives for personal use. In the datacenter you should be using RAID and/or backup or redundancy method in which case a single drive failure isn't something you waste time trying to analyze or fix.

I've run into 3 major types of drive failure:

1. PCB Failure: A case in which the PCB has been "fried". This happened dramtically once when connected an IDE drive to a system and let the disk rest, upside down, ontop of the case. It ran fine for aminute and then pop/spark there was a hole burned in a chip on the PCB. In this case the only solution is to go to eBay and buy an identical drive and swap the PCB.
2. Click of Death: This means catastrophic damage to a drive. The head is unable to position itself or read data and sweeps the platters in a sort of seizure. This is the sort of problem that likely requires you to open the drive or spend big bucks.
3. Damaged Cylinders: This is the kind of problem where the drive seems fine, mounts up and you can read for a bit and then hits some area of the platters where it freaks out and eventually spins up and down. This is most clearly seen when you image the drive with dd and it hits some point and exits on max retries.

Information on drive forensics and recovery is sparse. You tend to get one of three answers:

1. "d00d, totally put it in the freezer and then try it!" Variations come based on how you should protect against condensation, the best I've heard is to pack the drive in minute-rice.
2. "Send it to DriveSavers" (or other) This is super expensive, anywhere from $600 up beyond $2,000. You send them the failed disk and optionally a new drive to restore to. This can take weeks and is only for super extreme cases.
3. "Just download tool xyz.." There are lots of various software solutions for do-it-yourself drive recovery, most are old DOS based programs recommended on forums populated largely by Windows users.

In my most recent failure, the drive died one day for seemingly no reason. There was no impact or horror story, the OS just locked up, I rebooted and the OS would start to load and then just drift into an infinite slumber. I went through the painstaking process of replacing the drive in my MacBook Pro and re-installed everything from scratch. Once back up and running I put the old drive in a USB enclosure and attempted to image it using dd. Every attempt it would get 19GB into the drive and then give up.

This kind of problem is the easiest to deal with. There are special versions of dd, namely GNU ddrescue, which is just like dd, but instead of failing on bad blocks will track forward after a number of retries untill its read the whole disk, for better or worse.

In the case of my MacBook Pro drive I attached the USB enclosure to my OpenSolaris box, installed ddrescue, and imaged the drive to a file. Of the 80GB drive the tool reported that I lost about 250MB. I then created a ZFS ZVol of 80GB, used traditional dd to copy the image file into the volume, and then exported as an iSCSI target using iscsitadm. Using the globalSAN iSCSI Initiator for OS X I mounted the iSCSI Target, and used OS X "DiskUtility" to verify and repair the HFS+ Volume. All went well and I could then mount the volume and extract data. w00t!!! iSCSI Rules!

The tale of Tamarah's MacBook drive didn't end so happily. I had a backup of her laptop but it was really old. Glenn, our son, grabbed the laptop on the table sending it crashing to the tile floor below, hitting on the corner where the drive sits. The laptop was fine, but the drive was toast. After a Mac Genious showed us how to replace the drive I bought a new disk at Fry's and got things installed and running again, but the drive contained a lot of projects she wanted, and is commonly the case, when I showed her the data from the old backup she was uncertain as to whether it was enough. This is a big problem of the "unknown", when all your stuff is in one place you commonly forget what exactly is there.

I tried the USB enclosure trick but the drive wouldn't even spin up... click of death. Given the sensativity of the data I didn't want to go Rambo on the disk and so we sat down and had a serious discussion about whether or not it was worth having sent to a drive recovery company. The look on her face was enough to tell me what to do, and despite her guilt over the cost I sent it in. After a week and a half, the answer came back "nothing we can do". The tech was friendly and we had a good discussion about drive recovery, but long story short there was no hope and we were out $800. Frankly, for a lot of people that money is well spent because at least you exhausted all avenues, morn and get on with it.

When it comes to hardcore "swap the platters" style repair things get dicey. As simplistic as hard drives seem there are a lot of gotchas that you won't be aware of until its too late. This is where Scott Moulton of MyHardDriveDied.com comes in. Scott has done two presentations, both found on YouTube that provide a solid background for the black-art of hardcore drive recovery used by most of the big bucks recovery companies.

The first presentation is Hard Drive Recovery, available in 5 parts. This is followed up (a year later) by Advanced Hard Drive Data Recovery, again in 5 parts. Both presentations include excellent flash animations that illustrate his presentation perfected.

You can find even more videos by Scott on his SuperFlyFlippingA YouTube Channel, including an excellent presentation on SSD Flash vs Hard Drives.

Scott Moulton has done an amazing service to the community by providing detailed and experienced information regarding hard drive tinkering and recovery, including things you would never otherwise consider such as "Live PCB Swap"... watch and learn. :)

Of course, an ounce of prevention is blah blah blah. Technologies like OS X TimeMachine and ZFS make backup easier and more realistic than ever before and most importantly reduce data duplication significantly. Online backup solutions are good, but frankly are only feasible on very high speed lines in this era where a trip to the beach can result in 2GB's of new pictures. What I like best is the emergence of wi-fi USB Drive solutions that allow solutions like TimeMachine to backup whenever it likes without specially being hooked up to a drive... the more you back up the less there is to back up and the less hassle it is.

As a closing note... recovering the data is only part of the solution. I've found that some Apple apps like iPhoto and iTunes can be very unhappy when you attempt to import into a new system install. For instance, attempts to open my old iPhoto library have been unsuccessful. Thankfully I found iPhotoExtractor. As for iTunes, sadly iPods are not a backup solution... when attaching to a new system, even after authorizing, you may be told you need to delete and resync. In those cases, Sci-Fi Hi-Fi's PodWorks can come to the rescue allowing you to extract and import music from otherwise unusable iPods.

I think code_swarm is the most awesomest thing I’ve ever seen. Go watch the Apache video. Seriously cool stuff.

Thanks to Jaime Thomas for pointing this out (and, generating an Ewl video).

I am in no way qualified to speak with regard to whats going on around Blastwave, but given that there are no official statements and lots of rumors and speculation I'll share some info. Please note that I consider both Phil Brown and Dennis Clark as friends and am completely impartial, at least for this post.

If you've visited Blastwave.org recently you'll notice that parts of the site are "missing", you may also have noticed that Genunix was down for a bit. Threads regarding this issue have appeared both on OpenSolaris Discuss and comp.unix.solaris. A nice lengthy discussion was had with Dennis Clark today in #opensolaris, however I shall not quote that conversation directly, over 250 people were in the room at the time.

In the simplest possible terms, Dennis Clark and Phil Brown are in the process of parting ways. Phil Brown is the creator of the CSW (Community SoftWare) effort including the popular apt-get like pkg-get which has been the center of what people think of Blastwave. Dennis Clark is the man behind Blastwave which has provided the large infrastructure and pool of resources around CSW. These two have been intertwined for a very long time and, due to difference over future direction has escalated into separation. Because of this intemate relationship between CSW and Blastwave over so many years this disconnect does, in many ways, resemble a messy divorce.

As seen in Dennis Clarks email to OpenSolaris Discuss lawyers are involved and action is reportedly being taken against Phil Brown. Furthermore, Blastwave Inc is in progress of incorporating in Canada. CSW now has a new home suncsw.de in Germany.

Blastwave is still in operation for now, and thanks to the various Blastwave/CSW package mirrors users should have been minimally impacted, if at all.

For more information please read through the 3 message threads linked above so you can read from the participants themselves. Phil and Dennis are both active members of the community, if you have questions or concerns I encourage you to respectfully and courteously contact them directly via email, lists, or IRC.

In closing, I will remind everyone that both Dennis and Phil have done amazing things for the Solaris community for many years, and they both have intentions (it would appear) to continue doing so; albeit separately. For years and years they provided the Solaris community, unrecognized by Sun at the time, with high quality software on both SPARC and X86. Regardless of which side you take or which story you read never forget that both Dennis Clark and Phil Brown, together with countless maintainers and volunteers, deserve our lasting respect and appreciation. I'm personally saddened to see the division, but thankful for what they accomplished together.

So, I’m not sure exactly where I was last time I wrote about my progress on Evas_Quartz… so I’ll just mention the things I know I’ve done recently…

1) Gradients work now! Except, only some of them. It seems that linear, sinusoidal, and angular gradients work, but I haven’t seen a radial gradient out of it yet. Not sure that this is my fault, but it really only seems reasonable that it is. I just haven’t figured out why yet (anyone care to help?)…

2) The biggest problems with the text block layout code (actually, the problems were with my functions for querying Core Text font metrics, as I knew) are all fixed now. Text blocks (at least the ones in Expedite, and the ones I made for my little throwaway test programs) all look great! A part of the solution is very clearly hackish, but it works for now. I’ve come back to this code, revising it massively, a few times during the project… one more pass should probably do it.

3) I spent a lot of time cleaning up memory leaks in #1 and #2. I suppose this is technically part of #1 and #2, but it happened more recently than the initial implementations. Heh.

In truth, I was leaking a lot. A legitimately embarrassing amount, at first… so in an afternoon, it went from >100MB (just silly!) to 100KB, and now it’s at 14KB (through the entirety of the test program). The remaining leak is somewhere in the image data access functions (image_data_put, I think)…

4) I’ve got bits and pieces of the Ecore bits started, if you count… nearly empty files compiling and installing properly as started. I haven’t added them to Git yet, and I have to find a home for them in Google Code SVN (since the root of that is currently the evas directory… oops). I think it’s pretty clear that between sorting out threads/runloops/etc. and … just … making Cocoa work like a more conventional system, I’m going to be at this part for well into the school year, which is fine with me (maybe I can convince Robb to point me in the right direction, once I can show him what’s up). But maybe there’s others that work like this, I don’t know. Carbon would certainly be literally a million times easier. Gah!

My PowerMac G4 seems to have stopped working. Luckily, Dad brought a G3 B&W home from our neighbor’s a few months ago, so check it out!:

What with crooked disks and a 300MHz CPU, the chances of this being a lasting solution are somewhat slim; I’m going to replace Trin with a small homebuilt machine (based off a Shuttle box)…

Also… this is running inside a chroot off of the Debian 4.0 install CD, so if it goes down… don’t look at me

Ahhhh! It’s been a long time since I last posted, but I’m back up and running for good, now (there’ll be another 24 hour outage when I move to RPI, but other than that, we should be good!).

I’ve replaced Trinity with a nice new machine, built from a bunch of parts I bought (all from Newegg, of course).

I initially tried OpenSolaris (which Mike is succeeding with), but between the package manager needing a serious amount of help and my general inexperience with a rather different OS, I had to go back to Debian. So, no ZFS for now, maybe next summer.

Here’s what’s what in the new computer:

2.53 GHz Intel Core 2 Duo (E7200)
2GB DDR2 RAM
2×750GB Western Digital Caviar SE16

all in a cute little Shuttle case (the K48). I had to later acquire an extra SATA cable and a ATA-to-SATA power cable (to get data and power for the second drive), but that wasn’t a problem…

The stock Intel fan sucks, as everyone has already noted, but Arctic Cooling’s fan simply doesn’t fit in the small case! (so don’t spend extra money on it… just… make the Intel one work!)

The most awesome bit: I get 106MB/s writing to the disk (and 60MB/s over AFP over Gigabit Ethernet, or about 80MB/s over SAMBA). Mike and I discovered that Apple’s SAMBA client is broken: I get about 2MB/s with SAMBA on OS X, but 60MB/s with AFP on the same system, and 80MB/s with SAMBA on Linux on the same machine. So, simply put, don’t use SAMBA from Leopard.

I had a thought yesterday about a feature I’d like to see in Nautilus or Finder…

If you’re anything like me, you probably keep a lot of crap on your desktop, mostly related to things you’re currently working on (and you file them away later). This certainly isn’t the most efficient system, and I can assure you that it’s not the prettiest.

So I thought… wouldn’t it be cool if you had a little menulet that allowed you to rapidly create directories (in a definable place, say ~/Documents/Projects, or something), and switch your Desktop between representing the contents of each of these project directories easily? If you could get this implemented, it would also allow you to assign a particular project’s directory to a Space/Virtual Desktop, I suppose, but I don’t use them, so I’m more interested in the thought of a cleaner desktop, and the inherent organizational improvements.

I shared this idea with Robb (who noted that he thought something similar might possibly be in KDE4, though none of us have paid much attention there), and he started to implement it in Nautilus, but discovered that, while Nautilus respects XDG_DESKTOP_DIR, there’s no way to convince it to reload the directory (SIGHUP, the most obvious choice, also causes the creation of a new browser window). He also noted that simply replacing the ~/Desktop folder won’t work, because, if you’ve registered for filesystem notifications on the old ~/Desktop, you’ll loose your notifications when you replace the directory.

Finder is a different story entirely. Apple uses some sort of magic to determine what directory is the Desktop, and I haven’t figured it out yet. It was very promising at first… I created two directories with files in them, deleted ~/Desktop (with root privileges, because a user can’t delete their own Desktop…), linked one of the new directories to ~/Desktop, and *BOOM* the files are there on my desktop. But that’s the only time it works… if you try to change the link, the desktop continues to represent the new folder, no matter what you do. I have a thought regarding chained links, but I’m not actually sure it’s going to work; I’ll try it tomorrow.

So! If anyone has any suggestions… now would be the time

We had some frozen shrimp in the freezer that needed to be eaten, so Tim and I took that on as our next cooking challenge. We found a recipe for Ancho Shrimp with Smoked Gouda Corncakes that would use up the shrimp, and be something other than chicken, which seems to be all we make. We also baked some chocolate white chip cookies and made a Orange Cream Punch as our drink.

After searching for ancho peppers, ancho chile pepper or some spice that could be a substitute, we struck gold at Shaw’s. We walked into the store, picked up lettuce for salad and basically walked into the pepper section, which just happened to have dried ancho peppers. With that most important ingredient, we set to work.

We started with our cookies, so that they could chill in the fridge because, apparently, that makes them better. We combined all of the ingredients, and even let Tim use the mixer—yikes! It was quite simple, besides the poofing chocolate and flour.

The first, and most important step in dinner was to make the corncakes that would accompany the shrimp. After mixing together all of the ingredients (and shredding our own Gouda cheese), I attempted to “spoon batter into oil by 1/4 cupfuls,” but that really didn’t work well. It was incredibly hard to know when the cakes were cooked, and how to flip them and just everything about them was painful. In addition, the corn was always exploding and releasing little spurts of hot oil, which always seemed to hit someone. So I gave that job to Tim, which may sound mean, but he did a really great job [ed.: lolno] making sure they were round and cooked. I was quite impressed. While he was doing that, I was de-tailing the shrimp and getting everything ready for making the shrimp sauce.

Once Tim was done, and I had done a set of dishes, we cooked the ancho peppers in butter. We let the oils, or whatever, seep out and we added the garlic. It smelled absolutely great—the ancho peppers had an “earthy” smell, and mixed with the garlic, it’s difficult to explain. The shrimp was added—and it looked like we could have stopped there. But we added the tomatoes and it looked even better. The peppers were removed, and we poured some of the shrimp and tomatoes over two corncakes on each plate.

Our drink for the night was orange sherbet, vanilla ice cream, Sprite and milk. I combined it all in a big bowl, and it turned out to be smoothie-like. It was actually quite great, but it didn’t really fit in with our dinner.

After we ate, we cooked the cookies, which turned out to be very good. They didn’t even burn—like the last chocolate cookies I made.

In the end, a really awesome meal that was a little difficult in places, but well worth the effort. It was questionable along the way, in my opinion any way, but it turned out to be a good choice of recipes. I think I would make all of these again, but maybe we should learn about corncakes and cooking things like that before we attempt it again—as that was very chaotic.

The first annual OpenSolaris Storage Summit is coming on Sunday, September 21st, to San Jose, to be followed by SNIA's Storage Developer Conference. This is really exciting. SNIA SDC is one of the best storage conferences in the world (along with USENIX FAST), and OpenSolaris is undoubtedly the more powerful storage platform on earth... this is an excellent opportunity to get a lot of excellent and rewarding information in a week and get to meet the minds behind the technology in OpenSolaris.

Among the speaker lineup, myself and Mike Shapiro are the keynote speakers. If you have any interest in the future of storage you do not want to miss Mike Shapiro! Trust me. You don't.

As for my keynote, I would love to get feedback from everyone on what you'd like me to talk about. I have some ideas on what I could speak about, but I really want to provide as much value to the attendees as possible, so if you have topics you want discussed please send them my way.

Among the topics I will address is the impact of "cloud computing" on the modern storage infrastructure, how it relates to "Open Storage", and where things are heading in the future. Storage is, hands down, the most complex aspect of the cloud infrastructure and we'll dig our heals into it together.

The event is free, so you have no excuse not to attend! Just add your name to the registration list and your in! Pricing for SDC to follow is very reasonable and a very good investment in yourself and your company. If your in the Bay Area you've got to attend... if your outside of the area, tell your boss that Ben Rockwood said you need to be there, they'll give in right away. :)

So, I revoked my Enlightenment CVS access today. With the recent license flamewars and the sudden switch from Bugzilla to Trac I’m sick of the politics surrounding the project. It isn’t fun anymore.

To that end, I’m giving Nathan the authority to do what he sees fit with my code in CVS (including changing the license if he so desires).

It’s been a long strange trip. Now to figure out what to poke at next.

• The first thing is suspend cvs activity to the server.
  
• Import the existing cvs tree(s) and a possible reorginizationg.
• He also intends to change the e17 directory and everything inside it to look similar to this: e17/apps/ -> apps/
  e17/docs/ -> docs/
  e17/libs/ -> libs/
  e17/proto/ -> proto/
  e17/test/ -> test/
  
  we already have:
  devs/ -> devs/
  
  and i want to put in other cvs modules:
  misc/ -> misc/
  eterm/ -> old/eterm/
  web/www -> www/
  e16/ -> old/e16/
  e_modules/ -> apps/e_modules

Since I start my new job at AideRSS on Tuesday in Waterloo, Stacy and I have been busy getting the condo ready for sale. I spent a good portion of today steam cleaning the carpet in the living room.

While the steam cleaner works well at picking a lot of gunk out of the carpet it doesn’t do so well with cat hair. The hair just kind of clumps together into balls. Stacy spent a bit of time picking these up as our vacuum cleaner sucks.

Once we got sick of this method we went and bought a Dyson. If you don’t have a Dyson go buy one, it’s awesome. We didn’t have to steam clean the bedroom as the Dyson made the carpet look new. Damn, the amount of cat hair that thing sucked up. Was an impressive sight.

So, with the carpets almost clean, the holes in the walls filled and primed and about 1/2 of our stuff shipped up to my parents house, we should be ready to have this place on the market in a few days.

Here’s to hoping for a quick sell.

Spencer Shepler is leaving Sun. I am saddened to see him go.

If you don't know Spencer's name, he's been an NFS giant for a long time and we all owe a debt of gratitude to him. Of his long list of accomplishments he is a a chair of the IETF NFSv4 Working Group and is the most prominent name on the NFSv4 RFC 3530.

Make sure to keep your eyes on his new blog.

I’ve been poking at Cocoa development for quite a while now. That said, I haven’t finished anything I’ve started as of yet. I start a lot of things and then move to something else. Stacy thinks I have a problem. To that end, I’ve started a small application for Stacy. Nothing special, it’s just designed to do simple tracking of invoices and payments for her freelance business.

Since I’ve actually got someone who wants to use the application I’ve actually got a reason to finish it. I’ve imported the initial application, Reckoning, into GitHub for all the world to marvel over my ability to click icons in Xcode and Interface Builder.

Since I’m working on the application I may as well write about it a bit as well. Hm, I think I mentioned something about not being able to do just one thing?

With that in mind, let’s begin.

As mentioned, Reckoning is a simple application to track invoices and payments. There are four main items that will be tracked: Clients, Invoices, Line Items and Payments. To get this party started fire up Xcode and create a new Core Data Application. (This maybe better as a Core Data Document based Application but I picked Core Data Application.)

I got started by developing the data model (well, developing the data model after reformatting the default code to match my personal style). Double click on the Reckoning_DataModel.xcdatamodel file to launch the data modeling tool.

Before we get into the data model tool I guess I should tell you a bit more about my data. The system will have the following structure:

• Client

• name :: string (default: New Client)
• invoice_period :: integer (default: 30)
• invoice_notes :: string
• contact_name :: string
• contact_email :: string
• address :: string
• city :: string (default: Toronto)
• province :: string (default: Ontario)
• postal_code :: string
• country :: string (default: Canada)
• invoices :: to-many relationship to the Invoice table

• date :: date (default: “today”) [note the quotes matter for the date fields]
• due_date :: date (default: “today”)
• notes :: string
• taxes_saved :: float
• total_invoiced :: float
• total_received :: float
• client :: relationship to the Client table
• line_items :: to-many relationship to the LineItem table
• payments :: to-many relationship to the Payment table

• date :: date (default “today”)
• description :: string
• hours_worked :: float
• rate :: float
• invoice :: relationship to the Invoice table

• amount :: float
• date :: date (default: “today”)
• invoice :: relationship to the Invoice table

You’ll end up with something similar to the figure below in the data modeler.

Reckoning Data Model

About the only item not mentioned in the above is the regular expression used to validate the email address. After a bit of Googling I found a great resource on matching email addresses and entered ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4}$ as the contact_email regular expression.

Simple enough. Although, writing this I realized I forgot the default_rate field in the Client table. Oh well, something to do tomorrow.

The next step in our application is to start the user interface. For the first revision I’ve created the ability to add clients, invoices and payments. You can’t edit many of the details yet but the basic creation is there. (I’ll actually have to write some code to get that part done.)

Closing the data modeler tool we can now click on the MainMenu.xib (or .nib if you’re using an earlier version of Xcode) to launch Interface Builder.

Currently everything happens in the main Reckoning window. I’ll need to add sheets and property dialogs and things as time goes on but for now, one window.

Main Reckoning Window

The three fields in the Income section are set to non-editable text fields with a number formatter attached. All three number formatters are set to the currency style. (These three boxes do nothing in the current version.) The Due Date and Date columns have a date formatter attached. The Amount column has a currency formatter similar to the Income fields.

About the only other thing that needs explanation is the 7 outstanding invoices. This line will dynamically update in the final version of the app to give information on the outstanding and overdue invoices for each client. I’m also hoping to be able to colour the table cell text differently depending on the invoice status.

The Edit buttons are currently unused. The + and - buttons are used to add and remove items from their section.

Ok, lets see how much of this thing we can hookup without diving into any code.

First up, we need some controllers. We have three Core Data tables we’re going to want to pull data from for this first iteration. To that end we’ll drag three array controllers from the library down to the information window. Set the name of one to Client Controller, one to Invoice Controller and one to Payment Controller.

Information Window

In the inspector set the mode of all three to Entity and set the Entity Name to the corresponding entity name in our data model (Client, Invoice and Payment respectively).

Next up are the bindings for our array controllers. We’ll start with the Client Controller.

Client Controller Bindings

This is the simplest controller to hookup. We just have to tell the controller that it will be getting its Managed Object Context from the Reckoning_AppDelegate using the mangedObjectContext Model Key Path. The Reckoning_AppDelegate was created for us when we created the application.

Next up is the Invoice Controller.

Invoice Controller Bindings

You’ll notice an extra section to our bindings for this one. The bottom, Managed Object Context binding, is setup exactly the same as our Client Controller. The extra binding, the Content Set binding, allows us to bind the content of the Invoice Controller to the currently selected item in the Client Controller. This way we’ll only show the invoices for the selected client. So, you can see we’ve bound to the Client Controller with a Controller Key of selection and a Model Key Path of invoices. What this is doing is taking the current selection from the Client Controller and retrieving the array returned from the invoices method. The invoices method was created for us by Core Data based on the invoices relationship we created in our model.

Finally the Payment Controller.

Payment Controller Binding

This one is very similar to the Invoice Controller binding. We just bind to the Invoice Controller instead of Client Controller and we want the payments key path in the invoice model.

Sweet, our arrays are now hooked into our Core Data model and are ready to populate our tables. We’ll bind the Clients table first.

Client Table Bindings

Nothing too complicated in there. We want to bind the Value binding for the Table Column (make sure you have the Table Column and not the Table View or Text Field Cell or the Scroll View). We bind to the Client Controller as it’s the client information we want to display. We use the Controller Key of arrangedObjects which will return the objects in the given controller. I setup the cells to display the name of the client so we use the name key path into the Client object. I’ve also checked the Continuously Updates Value field. I’m not sure what this does but one of the tutorials mentioned it so I use it. If you know, please let me know.

We now move onto the Invoicing table.

Invoicing Client Column Bindings

This is similar to our Client bindings from above. We want to bind to the Invoice Controller and I’m using a different model key. The model key is set to client.name. This allows me to retrieve the name field of the client associated with this invoice. (Remember we have a relationship from Invoice to Client in our model.) You can use the dot notation to chain these methods together to pull out the exact information you require.

The Due Date column is the same except I bind the model key to due_date.

Finally the Payment table is basically the same bindings. For the Client column I bind the model key to invoice.client.name to pull out the client name for the invoice associated to this payment. The other fields just bind to date and amount respectively.

Cool. Ok, we can now display the data stored in our Core Data model. I guess it would help if we could actually add some data. If you haven’t noticed, pretty much everything we’ve done has been fairly easy (assuming you know the right syntax for the model keys and the controller keys.) Hooking up add and remove is no different.

If you option-click on the + symbol in the Clients section you can drag (and a blue line will appear) down to the Client Controller. Releasing the mouse you’ll see a popup. Select the add: entry. Do the same option-click and drag from the - button and select the remove: entry.

Follow the same procedure for the buttons in the Invoicing and Payments sections.

Save the file in Interface Builder, switch back to Xcode and run the application. You should be able to add clients, invoices and payments and hitting apple-s will save the file. If you close Reckoning and re-open you should see your created data populating the tables.

Not bad for not actually writing a line of code, eh?

Next time we’ll be attempting to hookup the Edit buttons for the client and invoicing information.