6th June, 2025

Swift 6 concurrency checking made handling notifications without warnings kinda tedious. The old Combine approach doesn’t work with @Sendable closures and manually managing tasks gets repetitive. I made a couple of tiny Swift packages to help out with the situation: AsyncMonitor which wraps task management, and NotificationSmuggler which adds a type-safe interface on top of Notification and NotificationCenter.

The manual approach

Here’s what I was writing over and over:

// Causes Sendable warnings in Swift 6
let task = Task { [weak self] in
    for await notification in NotificationCenter.default.notifications(named: .NSCalendarDayChanged) {
        guard let self else { return }
        await self.handleDayChange()
    }
}
// Store it somewhere, hope you remember to cancel it...

And when you have a bunch of these then you wind up with lots of properties to track them and other boilerplate.

AsyncMonitor

AsyncMonitor wraps the task lifecycle. Instead of managing tasks manually you use streams like Combine publishers:

import AsyncMonitor

let cancellable = NotificationCenter.default
    .notifications(named: .NSCalendarDayChanged)
    .map(\.name)
    .monitor { _ in
        print("The date is now \(Date.now)")
    }

The monitor method creates a Task internally and handles cleanup when the cancellable goes out of scope. The closure is async so you can await in it.

You’re free to do the usual [weak self] and guard let self else { return } dance, but there’s a variant that accepts a context parameter that’s automatically weakified. Your closure receives a strong reference:

let cancellable = NotificationCenter.default
    .notifications(named: .NSCalendarDayChanged)
    .map(\.name)
    .monitor(context: self) { _self, _ in
        _self.dayChanged()
    }

The monitor finishes automatically after finding a nil context.

Cancellation tokens

Similar to Combine there’s the concept of a cancellable that ties the observation to the lifetime of that cancellable instance. And of course, we call it a dispose bag. Just kidding obviously, it’s called AsyncCancellable and there’s an AnyAsyncCancellable type-erasing wrapper. So very much like Combine you write this:

import AsyncMonitor

class Whatever {
    private var cancellables: Set<AnyAsyncCancellable> = []

    func something() {
        NotificationCenter.default
            .notifications(named: .NSCalendarDayChanged)
            .map(\.name)
            .monitor { _ in /* ... */ }
            .store(in: &cancellables)
    }
}

KVO

Sometimes you need KVO and the old ways are best. There’s a KVO extension that bridges to async sequences:

// AVPlayer's Combine publisher for rate doesn't publish all the values
player.monitorValues(for: \.rate) { rate in
    print("Player rate: \(rate)")
}.store(in: &cancellables)

What about Combine?

Combine works but doesn’t mesh well with Swift 6 concurrency. The @Sendable requirements make it annoying. You can write the Task code manually but it gets repetitive when you have a lot of observers.

NotificationSmuggler

NotificationSmuggler solves a different problem: type-safe notifications. No more dumpster diving in userInfo.

Define your contraband:

import NotificationSmuggler

struct ProjectExportComplete: Smuggled, Sendable {
    let projectID: String
    let outputURL: URL
}

The Smuggled protocol generates a unique notification name and userInfo key from your type name.

Smuggle your illicit goods like so:

NotificationCenter.default.smuggle(ProjectExportComplete(projectID: "project-123", outputURL: exportURL))

// which is short for

NotificationCenter.default.post(.smuggle(ProjectExportComplete(projectID: "project-123", outputURL: exportURL)))

And on the other side it’s as easy as any other notification using an extension on NotificationCenter:

for await notification in NotificationCenter.default.notifications(for: ProjectExportComplete.self) {
    print("Project \(notification.projectID) exported to \(notification.outputURL)")
}

Using them together

They work well together. Here’s a more full example:

import AsyncMonitor
import NotificationSmuggler

struct BackupCompleteNotification: Smuggled, Sendable {
    let success: Bool
    let totalSize: Int64
}

NotificationCenter.default
    .notifications(for: BackupCompleteNotification.self)
    .monitor(context: self) { _self, notification in
        _self.updateBackupStatus(success: notification.success)
    }.store(in: &cancellables)

// elsewhere

NotificationCenter.default.smuggle(BackupCompleteNotification(success: true, totalSize: 42))

That’s it

Both libraries are small and focused. AsyncMonitor is about 100 lines, NotificationSmuggler is smaller. Zero dependencies.

AsyncMonitor requires iOS 17. It supports both iOS 17 and iOS 18 with different initializers due to changes in inheriting actor isolation.

• AsyncMonitor on GitHub
• AsyncMonitor on Swift Package Index

NotificationSmuggler requires iOS 17.

• NotificationSmuggler on GitHub
• NotificationSmuggler on Swift Package Index

∞

18th April, 2024

It would be cool to open up the Photos app to a specific asset on iOS, just like the Photo Shuffle lock screen.

There are some references to the photos-navigation URL scheme out on the web but they all effectively just say that they have no clue how to actually use it. And the obvious guesses haven’t worked for me. The only way forward was to roll up my sleeves and dive into some aarch64 assembly, which is a bit of an adventure because I don’t know anything about that architecture.

Decompiling the Photos app (a.k.a. MobileSlideShow) and looking through the methods -[PhotosWindowSceneDelegate openRoutingURL:] and -[PhotosURLNavigationRequest _navigateAllowingRetry:] uncovered some candidates:

• photos-navigation://asset?uuid={uuid}
• photos-navigation://album?name=recents&revealassetuuid={uuid} (opens the album so at least that’s something, but not my goal)
• photos-navigation://contentmode?id=photos&assetuuid={uuid}&oneUp=1

Opening up an album by name works but so far I’ve had no luck figuring out how to show a specific asset. And ideally it would open up in the Library tab and not the Albums tab, just like the Photo Shuffle lock screen.

An interesting tidbit I learned along the way is that there are a handful of well-known named albums and those are the only identifiers allowed for the name parameter, you can’t just pass the name of any album. The known album names from -[PhotosURLNavigationRequest _albumForKnownName:orUUID:requestIsValid:] are the following:

• photo-library
• recents a.k.a. camera-roll
• favorites
• all-imported
• last-imported
• recently-deleted

And some other hosts / actions that seem to be supported:

• photos-navigation://oneyearago
• photos-navigation://memories
• photos-navigation://people

It looks like these are supported for the photos: URL scheme as well but I had zero luck opening that URL at all, rather than the photos-navigation: scheme which at least opens the app in all cases.

The next step might be trying to figure out which app/framework handles the Photo Shuffle lock screen and then decompile that to figure out which URL it calls.

Update 2024-10-11: photos-navigation://memories works on the iOS 18.1 beta however I’ve still had no luck with navigation to a specific asset.

∞

6th October, 2017

Swift compile times leave something to be desired and a common culprit is the affectionately-named nil-coalescing operator. A small extension to Optional can improve this without sacrificing a lot of readability.

extension Optional {
    func or(_ defaultValue: Wrapped) -> Wrapped {
        switch self {
        case .none: return defaultValue
        case let .some(value): return value
        }
    }
}

And you use it like so:

let dict: [String : String] = [:]
let maybeString = dict["not here"]
print("the string is: \(maybeString.or("default"))")
let otherString = dict["not here"].or("something else")

I’m sure someone else has come up with this already but I haven’t seen it yet.

(gist available here)

∞

10th August, 2016

It’s not hard to hide a whole lot of complexity behind a function call, so you have to be very aware of what the functions you are using actually do, and how long they take to do it.

Here’s some example code illustrating a big performance problem I found in a codebase I’ve inherited. We have a dictionary keyed by a string representing a date, e.g. “2016-08-10”, and where the values are arrays of videos for that given date. Due to some unimportant product details videos can actually appear in more than one of the array values. The goal is to get an array of all videos, sorted by date, and with no duplicates. So we need to discard duplicates when building the sorted array.

func allVideosSortedByDate(allVideos: [String:[Video]]) -> [Video] {
    var sortedVideos: [Video] = []
    // sort keys newest first
    var dateKeys = allVideos.allKeys.sort { $1 < $0 }
    for key in dateKeys {
        for video in allVideos[key] {
            if !sortedVideos.contains(video) {
                sortedVideos.append(video)
            }
        }
    }
    return sortedVideos
}

Can you spot the problem here? sortedVideos.contains(_:) is an O(n) algorithm which means that in the worst case it has to look at every single element of the collection to check if it contains the given item. It potentially does n operations every time you call it.

Because this is being called from within a loop that’s already looping over all n items, that makes this an O(n2) algorithm, which is pretty terrible. If you ever write an n2 algorithm you should find a better solution ASAP. There almost always is one! If we have a modest collection of 1,000 videos that means we have to do 1,000,000 operations to get a sorted array of them. That’s really bad. One measly line of innocuous looking code completely blew the performance of this function.

In this particular case my first instinct is to reach for a set. We want a collection of all the videos and want to ensure that they’re unique, and that’s what sets are for. So what about sorting? Well we can build up the set of all videos, then sort that set, converting it to an array in the process. Sounds like a lot of work right? Is it really faster? Let’s see what it looks like.

func allVideosSortedByDate(allVideos: [String:[Video]]) -> [Video] {
    var uniqueVideos: Set<Video> = []
    for key in allVideos.allKeys {
        for video in allVideos[key] {
            uniqueVideos.insert(video)
        }
    }
    // sort videos newest first
    let sortedVideos = uniqueVideos.sort { $1.creationDate < $0.creationDate }
    return sortedVideos
}

The for loops are still O(n) and now we’ve shifted some work outside of those loops. After the O(n) loops we have a sort method that is probably something like O(n * log n), which is fairly typical. So the total complexity of the function is O(n + n * log n). In order to simplify this we can inflate the first term a bit by increasing it to n * log n as well, making the whole thing O(2n * log n), and since we discard constants that’s O(n * log n) overall.

Putting the constant back in let’s see how many operations it now takes to get an array of all videos sorted by date. Again saying we have a modest collection of 1,000 videos, that’ll be 2 * 1,000 * log 1000 → 2,000 * 3 → 6,000 operations to do the whole thing. A far cry from 1,000,000!

Getting practical, in this case running the original function against 4,990 videos takes 29.653 seconds on an iPhone 4S. Running the new function against the same set of videos takes 4.792 seconds. Still not great and there’s room for improvement, but that was a big, easy win already.

Mind your algorithms folks, it makes a huge difference in the real world.

∞

4th August, 2016

Krzysztof Zabłocki wrote a nice article on using a git pre-commit hook to catch mistakes in iOS projects before you push those mistakes out to the whole team/world. It’s a great idea! But the shell script has some problems, so let’s fix those.

If you don’t care what I did or why then you can just see the updated script.

Repeated code

The diff command is repeated. This is any easy win:

diff-index() {
    git diff-index -p -M --cached HEAD -- "$@"
}

if diff-index '*Tests.swift' | ...

You get the idea.

Portability

One problem is that the bootstrap script uses an absolute path when creating a symlink to the pre-commit script. That’s no good because then your pre-commit hook breaks if you move your project somewhere else.

That’s easily fixed by using a relative path to your pre-commit hook, like so:

ln -s ../../scripts/pre-commit.sh .git/hooks/pre-commit

Ah, this is more flexible! Of course if you ever move the script itself then it’s on you to update the symlink and bootstrap.sh, but that was already the case anyway.

Show me the errors

Ok great so this script tells me there are errors. Well, script, what exactly are those errors?

First ignore the fact I’m talking to a shell script. I don’t get out much. Anyway… now we need to pull out the regular expressions and globs so we can reuse them to show what the actual errors are if we find any.

test_pattern='^\+\s*\b(fdescribe|fit|fcontext|xdescribe|xit|xcontext)\('
test_glob='*Tests.swift *Specs.swift'
if diff-index $test_glob | egrep "$test_pattern" >/dev/null 2>&1
...

Pro tip: I prefixed test_pattern with \b to only match word boundaries to reduce false positives.

And:

misplaced_pattern='misplaced="YES"'
misplaced_glob='*.xib *.storyboard'
if diff-index $misplaced_glob | grep '^+' | egrep "$misplaced_pattern" >/dev/null 2>&1
...

You may notice that I snuck in *Specs.swift as well. Let’s not be choosy about file naming.

Then we need to show where the errors are by using diff-indef, with an || true at the end because the whole script fails if any single command fails, and git diff-index regularly exits with non-zero status (I didn’t look into why that is).

echo "COMMIT REJECTED for fdescribe/fit/fcontext/xdescribe/xit/xcontext." >&2
echo "Remove focused and disabled tests before committing." >&2
diff-index $test_glob | egrep -2 "$test_pattern" || true >&2
echo '----' >&2

And for misplaced views:

echo "COMMIT REJECTED for misplaced views. Correct them before committing." >&2
git grep -E "$misplaced_pattern" $misplaced_glob || true >&2
echo '----' >&2

Fix all the things, at once

The third problem is that if there are any focused or disabled tests you won’t be told about any misplaced views until you try to commit again. I want to see all the errors on my first attempt to commit, and then fix them all in one fell swoop.

The first step is to exit at the end using a code in a variable that is set to 1 when errors are found, so we always run through both branches even when the first has errors.

Up top:

failed=0

In the middle, where we detect errors:

failed=1

And at the bottom:

exit $failed

That’s all there is to it. If we don’t exit early then all the code runs.

General Unixy goodness

Error output should be directed to stderr, not stdout. I littered a bunch of >&2 around to rectify that situation.

Final countdown

Those were all the obvious improvements in my mind and now I’m using this modified version in my project. If you come up with any more nice additions or changes please share! Fork this gist.

Here’s the whole thing put together:

#!/usr/bin/env bash
#
# Based on http://merowing.info/2016/08/setting-up-pre-commit-hook-for-ios/

set -eu

diff-index() {
  git diff-index -p -M --cached HEAD -- "$@"
}

failed=0

test_pattern='^\+\s*\b(fdescribe|fit|fcontext|xdescribe|xit|xcontext)\('
test_glob='*Tests.swift *Specs.swift'
if diff-index $test_glob | egrep "$test_pattern" >/dev/null 2>&1
then
  echo "COMMIT REJECTED for fdescribe/fit/fcontext/xdescribe/xit/xcontext." >&2
  echo "Remove focused and disabled tests before committing." >&2
  diff-index $test_glob | egrep -2 "$test_pattern" || true >&2
  echo '----' >&2
  failed=1
fi

misplaced_pattern='misplaced="YES"'
misplaced_glob='*.xib *.storyboard'
if diff-index $misplaced_glob | grep '^+' | egrep "$misplaced_pattern" >/dev/null 2>&1
then
  echo "COMMIT REJECTED for misplaced views. Correct them before committing." >&2
  git grep -E "$misplaced_pattern" $misplaced_glob || true >&2
  echo '----' >&2
  failed=1
fi

exit $failed

∞

12th April, 2016

Today I scheduled PRK laser eye surgery on April 19th. Exciting but also kind of terrifying because the procedure sounds a bit horrific. Most accounts from people don’t sound very bad though so the operation itself should be a breeze! I scoured the web for PRK recovery stories to get an idea of what I was in for and found some good quotes.

Munchkin had the surgery in South Africa 2 weeks prior to flying to the UK. Doesn’t sound like the best idea.

The journey back to the UK was tricky. I couldn’t quite make out the signs in the airport, and I had to walk right up to boards to read them.

Unfortunately they also failed to get as good of a result as many others.

I also now have glasses, which I use for driving and if I need to see detail at a distance (e.g. in meetings). I didn’t know glasses in the UK would be so expensive, but at least I didn’t have to splurge on thinner lenses; the standard Boots lenses were just fine! My eyesight is now -1.00 on the right, -0.25 on the left. I can continue to function at home, outside and at work generally without glasses.

lechlitnerd on reddit:

Now, everyone has their own thresholds for pain. And before the procedure, I knew that PRK would have its discomforts. But I was not prepared for this searing pain. I woke up from my nap, and it felt like someone had rubbed chili peppers in my eyes. They burned!

Alex Tran’s Scout leaders may not have been that great at campfire safety.

At this point, I was ready for the laser. I heard the machine rev up and the laser started zapping quickly. Luckily I was able to keep my eye completely still so the laser didn’t stop at all. It took about 35 seconds, zap by zap. There was no pain but you could definitely smell the burning eyeball. The smell reminded me of scout camp.

Anson Kao had a pretty good reaction to the Valium. If only we all could be this lucky.

I found that the surgery was actually very entertaining! It’s kinda like your eyes are going through a car wash. After popping a Valium, you relax and just lay on your back while the surgeon does everything. Thanks to plenty of freezing drops, you can’t even tell when the surgeon touches your eye – you just watch it all unfold like a movie.

∞

30th March, 2016

This is all good advice. I should use more intermediate variables for longer conditions.

∞

28th March, 2016

I really like this style of modularity in C and Lisp. Using delegation and other patterns you can go a really long way without inheritance too.

∞

27th August, 2015

This is exactly what I want to see from my VPN. Good stuff.

∞

25th August, 2015

If you make Mac software please look into this. It looks sweet.

∞

9th July, 2015

This is all good stuff. I need to spend more time reading the Swift 2 book.

∞

1st July, 2015

I really like this idea. I try to make bootstrap scripts for most projects but can do better.

∞

2nd June, 2015

Yoink.

∞

1st June, 2015

One of the least documented aspects of the configuration process are xcconfig files. As of this writing there seem to be no documents provided by Apple that explain how to use xcconfigs or why they exist. A xcconfig file is used as a supplemental file to a specific build configuration. A build configuration can have an associated xcconfig file, this allows for additional changes to the target’s build settings from outside the Xcode project editor.

∞

28th May, 2015

I’m going to snag bclean and bdone and add them to my git aliases.

∞

27th May, 2015

When everything works, the reader flashes green and emits a pleasing tone; if something goes wrong, it glows blue—never red. Red lights are forbidden at Disney, as they imply something bad happened. Nothing bad can happen at Disney World.

∞

24th May, 2015

You can upgrade a drive to a Fusion drive in-place with these commands. Without cloning or reinstalling. convert, addDisk, then resizeVolume.

∞

22nd May, 2015

Being an iOS developer, it wouldn’t make sense to buy a Windows machine. But this looks like one hell of a notebook. I love that it has an LTE option.

∞

19th May, 2015

A wide variety of new internet-connected devices require an associated SAAS subscription to work. Rather than paying a number of different subscription bills, by including the right-sized 21 BitShare with the device one can under many scenarios wholly or partially defray the expense of the cloud service.

I’ve joked about shipping apps that mine bitcoins instead of showing ads. Now hardware vendors can easily do the same thing. We live in interesting times.

∞

15th May, 2015

Looks like a nice improvement.

∞

12th May, 2015

It’s great that Apple added this but I don’t understand why Foundation and UIKit aren’t imported automatically when you’re writing an iOS app.

∞

10th May, 2015

Time to read this again now that I’ve had a watch for a few days.

∞

3rd February, 2014

I made a diagram of an Ember app. There’s a discussion about it on the Ember Discussion Forum. Here is the source file, created with OmniGraffle: Ember structure.graffle

∞

27th September, 2013

Send links from mobile devices to your computers.

The last few months I’ve been annoyed by my workflow for sending links from my touch devices to my computers. For example if I come across a cool Mac app or an open source project I want to check out, or anything along those lines. Until now I have been mailing links to my work or home addresses, or saving links in Instapaper. The problem with both of those is the same: I have to remember to check something when I arrive at the correct machine. It sounds trivial but I have been annoyed by it nonetheless.

This weekend I finally decided to scratch that itch and ended up writing much less code than I imagined to accomplish it in a perfectly acceptable way. The components are:

• Gmail
• IFTTT (If This Then That)
• DropBox
• NorthWatcher
• a (short) Ruby program
• terminal-notifier (which displays native notifications in OS X)

Yup, that is a lot of moving parts. It is rather elegant in a Unixy way though.

I experimented with Gmail → IFTTT → Boxcar → Growl, but Boxcar’s Mac app is really rough and didn’t seem to pick up new messages at all, let alone quickly, so I fell back to a solution with more parts.

Gmail

Gmail allows you to append extra info to your email address in the username, which you can use for filtering and labeling. I send links to sami.samhuri+linky@gmail.com and then filter those messages out of my inbox, as well as applying the label linky. Using email as the entry point means that basically every app I use already supports sending links in this way.

IFTTT

IFTTT (If This Then That) can wire up services, so that events that happen in one place can trigger an action elsewhere, passing along some info about the event along with it. In this case when a new email arrives in my Gmail account with the label linky then I create a text file in Dropbox that contains two lines: the title, followed by the link itself.

For example, the following lines would be created in a file at ~/Dropbox/Linky/Ruxton/<generated filename>.txt for my machine named Ruxton.

Callbacks as our Generations' Go To Statement
http://tirania.org/blog/archive/2013/Aug-15.html

The filename field is defined as:

{FromAddress}-{ReceivedAt}

And the content is:

{Subject}<br/>
{BodyPlain}<br/>

That means that when you email links, the subject should contain the title and the body should contain the link on the first line. It’s ok if there’s stuff after the body (like your signature), they will be ignored later.

I create one recipe in IFTTT for each machine that I want links to appear on. You could get fancy and have different Gmail labels for individual machines, or aliases, groups, etc. I’ve kept it simple and just have every link I send go to both my home & work computers.

Dropbox

Dropbox is fantastic. My files are never not everywhere. IFTTT creates the file in Dropbox, and then Dropbox makes sure it hits all of my machines. Did I mention that Dropbox is awesome? It’s awesome.

NorthWatcher

This is a quick and dirty thing I whipped up a couple of years ago, and now it’s come in handy again. It’s a program that watches directories for added and removed files, and then launches a program that can then react to the change. In this case, on each machine I want notifications on, I have it watch the Dropbox folder where IFTTT creates the text files. e.g. ~/Dropbox/Linky/Ruxton

It has a text configuration file kind of like cron. Here’s mine from Ruxton:

+ Dropbox/Linky/Ruxton ruby /Users/sjs/bin/linky-notify

That tells NorthWatcher to run ruby /Users/sjs/bin/linky-notify when files are added to the directory ~/Dropbox/Linky/Ruxton.

NorthWatcher is on GitHub and npm. Install node and then run npm install -g northwatcher. After creating the config file at ~/.northwatcher you can run it automatically using this launchd config file. Drop that in ~/Library/LaunchAgents/net.samhuri.northwatcher.plist. Don’t forget to update the working directory path, and run launchctl load ~/Library/LaunchAgents/net.samhuri.northwatcher.plist to load it up (afterwards it will load on boot).

A Ruby program, and terminal-notifier

Finally, we have the last two components of the system. A short Ruby program (/Users/sjs/bin/linky-notify) that reads in all the files NorthWatcher reports as added, and uses terminal-notifier to show a native OS X notification for each link. After displaying the notification it moves the text file into a subfolder named Archive, so I have a record of all the links I have sent myself.

You can get terminal-notifier with homebrew in a few seconds: brew install terminal-notifier. After you have used terminal-notifier you will be able to go into Notifications in System Preferences and change it from Banners to Alerts. Banners are transient, while Alerts are persistent and have action buttons: Show and Close.

Cool story, bro

It may not be exciting, but as someone who typically suffers from NIH syndrome and writes too much from scratch, I found it pretty rewarding to cobble something seemingly complicated together with a bunch of existing components. It didn’t take very long and only involved about 10 lines of code. It’s not exactly what I wanted but it’s surprisingly close. Success!

∞

6th March, 2013

Zelda

Matt Gemmell recently shared some sweet Super Nintendo wallpapers for iPhone 5. Although I don't have an iPhone 5 I was happy to snap them up and crop them for my 4S.

If you like that sort of thing then you might want these tones that I whipped up. The first pack is a few Zelda ringtones along with a few more SMS tones. Most of them are from A Link to the Past.

Get the Zelda tones

• Theme
• Overworld overture
• Song of Storms
• Secret
• Item
• Achievement

Pacman

The second pack is two Pacman tones.

Get the Pacman tones

• Pacman starts
• Pacman dies

O Fortuna

Okay okay, one last one. O Fortuna from Carmina Burana, composed by Carl Orff, performed by the London Philharmonic Orchestra.

• O Fortuna

Get the O Fortuna ringtone

Enjoy!

∞

19th January, 2012

Does this even warrant any comments on why it’s already a massive failure? The many, many drawbacks seem so apparent I cannot believe this escaped from their drawing board.

∞

17th January, 2012

rather than coming to the table to find solutions to a problem that all now seem to agree is very real and damaging.

No. All most certainly do not agree.

It is also an abuse of power given the freedoms these companies enjoy in the marketplace today. It’s a dangerous and troubling development when the platforms that serve as gateways to information intentionally skew the facts to incite their users in order to further their corporate interests.

This must be a joke. It’s a joke, right? Please tell me this joker is joking. The hypocrisy is too much.

stop the hyperbole and PR stunts and engage in meaningful efforts to combat piracy.

There is absolutely nothing reasonable that anyone can do to “combat piracy”. Digital copies are cheap. Adapt or die.

The VCR did not kill media industries. Nor the cassette, CD, DVD. Why should anyone believe that computers and the Internet are going to kill music and movies?

If the MPAA displayed even a shred of sanity maybe they would be taken seriously in their efforts to curb piracy. The biggest problem I can see is that studies have given us evidence that they are not hurt by it at all. Their tactic of choice seems to be to loudly decry “Nuh-uh! Piracy does hurt us!” and then strong arming everyone worldwide while suing anyone and everyone. If times are so tough maybe they should cut some of their budgets for lawyers and lobbyists.

∞

17th January, 2012

Something to keep in mind.

∞

9th January, 2012

Ultimately, I decided I might as well just do something cheap for now. So I built my own. I had thinking about doing it for a while when my coworker Steve Smith built his desk. After seeing his, I was convinced this was what I wanted to do. It turns out, the cheap option is pretty awesome.

This looks great. Might have to consider it when or if I get a desk.

∞

4th January, 2012

The best plain-english explanation of yak shaving I have seen.

∞