Daniel Nordstrom, Web & iOS Creator

Siri on iPod, Yes You Can

2013-04-11T00:00:00+02:00

About three years ago, an application called Siri went into the final stages of testing at a company with the same name: Siri, Inc. It was a seemingly simple personal assistant created for the iPhone and planned for other smartphones. As they submitted Siri to the App Store, little did its inventors know about the impact it would eventually have on smartphone technology.

Back then, voice recognition was dominated by applications such as today’s Dragon Dictate. These were large, complex applications for voice commands. They weren’t particularly smart, and they definitely weren’t anything you would slap on a smartphone just for the fun of it. Suddenly arrived this new, virtually unknown kid on the block; at half the size and claiming to have twice the brains.

The claims must have been true, because the application caught the attention of Apple, who ended up acquiring Siri, Inc. shortly after the release. As they say, the rest is history.

When iOS 6 was released, some people were glad that Siri would be available on the iPad. Others, like myself, remained disappointed that Siri was still unavailable for the iPod. The bad news is that this is still the case; the good news is that it doesn’t have to be.

Brilliant software, despite being useful to anyone, isn’t always available to everyone. It can’t be; such is reality. However, I’m a firm believer that when it easily can be, then it most often should be.

Therefore, a second story will now be told: the story of how an impatient and stubborn believer may enable Siri on her iPod Touch 4G. Fortunately, it’s a short and simple story.

How To Install Siri on an iPod

Jailbreak your iPod using Redsn0w, following the simple instructions provided in the app. More extensive guides can be found.
Remember to use Redsn0w to boot the iPod when you want access to jailbreak applications such as Cydia. If you are running iOS 6, you will want to download the official firmware IPSW file for your device and use it in Redsn0w (by clicking "Extras" and "Select IPSW"), whenever you boot your device, to enable the jailbreak features.
Launch Cydia and add the Siri repository as a source. Go to the "Manage" tab, tap "Sources," "Edit," and then "Add." Use the following URL: "http://repo.siriport.ru".
Install Siri by searching for, and installing, the "SiriPort (Original) iOS 6" package.
Go to Settings.app and choose "SiriPort.Ru Original." Tap to "Install Certificate" to allow Siri to talk to Apple's servers.

That’s all. While it may not work as flawlessly as the original Siri on a late model iPhone, it’s still Siri and it’s now on your iPod. Have fun with your new friend!

The Value of Being a Human Typewriter

2013-01-13T00:00:00+01:00

It was back in the old days—we were two sixteen year old hackers in an IRC chat room, and it was probably long past midnight. My friend half-jokingly told me my writing looked like that of a human typewriter, and at the time I took it more as an insult than a compliment. But that statement stuck with me, and with time my view of it has changed.

She didn’t mean that my writing was sterile or boring, or at least I hope she didn’t. She meant that I used capital letters at the beginning of sentences, that I tried to put a comma where it was supposed to be, and that I used em-dashes and semi-colons religiously (I always have). She meant that, as a young Swede caught up in a global web, I was constantly striving to perfect my writing. Formal or informal, in Swedish or in English—none of it mattered, and it still doesn’t.

For some reason, this will occasionally make people think you are weird. That never stopped me, and neither should it stop you. Catch a football enough times and it will eventually seem magnetically attracted to your hands, at which point it doesn’t matter that some think you’re weird: you’ll be a receiver for the New England Patriots, they won’t be. The same principle applies to writing. Strive for perfection in both formal and informal writing, and soon enough it will become a reflex.

Soon enough formal and informal will fade away. You will start thinking in better terms, terms like efficiency and comprehension. Your choices and decisions will become based on making your reader get what you’re trying to say. That is the goal of most of our writing, yet many of us pay little attention to it. We get caught up in our own thoughts, forgetting that our readers are not as familiar with them as we are.

What we want is writing that fits the occasion and the readership---and whether it's "formal" or "informal" by any individual's definition should not be a concern. Our primary concern should be clarity; the next should be economy.

Richard Lauchman, Punctuation at Work

By paying more attention, you will be better understood in any situation—that is a fact, a simple consequence of consistent effort. I would go as far as to say it will also improve, though to a lesser degree, your verbal communication skills. If doing something takes a little more effort and makes you a lot more efficient, common sense should tell you to do it. That is also my advise to you, and why I’m writing this right now.

I still have a long way to go, but being an obsessively compulsive typewriter has taught me a lot. It has taught me about the art of writing, and about the science and value of efficient communication. The statement that started this article, however, still to this day makes me remove a comma here and there, just to at least sound human in a world that increasingly is not.

Fix iTunes Error 16xx on iOS Custom IPSW Restore

2012-12-25T00:00:00+01:00

The problem

Attempting to restore your iPhone, or other iOS device, using a custom IPSW firmware file will cause iTunes to choke on an error in the 16xx range, such as error 1600 or 1604. Most people are experiencing this issue while performing a jailbreak of their iPhone or iPod, which is the main reason why you would be restoring your device using a custom firmware file. I was installing whited00r 6 to bring a more productive experience to my old iPhone 3G, since I can’t officially update it past iOS 4.3.2, when I suddenly bricked it.

Fix your iTunes 16xx error on restore.

The solution

The problem behind these error messages is that, when restoring from a custom IPSW file, the device needs to be put into a modified DFU mode, which a jailbreaking tool would normally do while guiding you through the process. Luckily, Redsn0w is a tool that helps you do this quickly and easily so you can get back to restoring your device using iTunes.

If you are getting the error message without attempting to restore your device using a custom firmware file, I suggest you first try the troubleshooting instructions on Apple’s website. Otherwise follow the instructions below to fix the issue.

The necessary software is available for both MacOS X and Windows.

Download Redsn0w.
Download the official IPSW file for your device and firmware, e.g. 4.3.2.
Launch Redsn0w, click “Browse”, and open the official firmware file you just downloaded.
When prompted to select your options, tick only “Just enter pwned DFU mode right now”.
Follow the instructions. Be ready to hold down the power button when prompted.
Once Redsn0w is done putting your device in DFU mode, relaunch iTunes and the custom firmware restore will work.

Redsn0w for Mac solves your iTunes 16xx error.

Easy as pie.

Book Review, Telling Lies by Paul Ekman

2012-08-13T00:00:00+02:00

It was several years ago that I started reading Telling Lies after finishing Paul Ekman’s more recent book Emotions Revealed. While Emotions Revealed can be considered a relatively light read on the subject of emotions and their relation to deception, Telling Lies is fascinatingly deep on the subject of lying itself.

Telling Lies by Paul Ekman.

The cover reads “clues to deceit in the marketplace, politics, and marriage”. While this subtitle is accurate, it does not quite reflect the complexity of what is described within the frames of the book. More so than just clues to deceit in both everyday and highly deadly historical situations, it to my delight goes into detailed discussion on the morality and rationality of the described predicaments.

When Lyndon B. Johnson lied about the Vietnam war, did he deceive only the American people or did he also deceive himself?

Should the ignorance that lead to the explosion of the Challenger space shuttle be blamed on the single person ignoring the many warnings from engineers, or should NASA managers be held accountable for creating an atmosphere where lying was authorized and even encouraged?

Though this book was published in 1985, it may still be the most accurate and thorough book on the subject of behavioral clues to deceit. This because it’s based on solid research leading up to, and building upon, the discovery of micro facial expressions and other clues in body, voice, speech and autonomic nervous system that changed the way behavioral scientists view deception, and because it bravely questions past research for being focused on utility as opposed to accuracy.

An important fact clearly stated throughout the book is that there is no universal sign of deceit. There are only universal signs of emotion. The polygraph machine does not detect deceit; it detects arousal of any emotion. The book goes into fascinating depth on what questions we may ask ourselves and others to not misinterpret or misunderstand emotions and the motives behind them.

This book was not written just for Norwegian investigative journalists. Anyone will benefit from learning how to be more understanding and sensitive to the behavior of others. As a word of caution, if you believe that ignorance is bliss you may want to stay far away from this book – it opens the door to many questions regarding ethics and an individuals right to emotional privacy.

Last but not least, literally, the epilogue of the book is full of insight and gives us a glimpse into the mind of one of our time’s greatest scientists:

My sympathy is more with the lie catcher than the liar. Perhaps it is because my scientific work is a search for the clues to how people truly feel. The disguise interests me, but the challenge is to uncover the real, felt emotion beneath it.

Discovering how felt and false expressions differ, to find that concealment is not perfect, that the false only resembles but differs from real expressions of emotion is satisfying.

The study of deceit, in these terms, is about much more than deceit. It provides an opportunity to witness an extraordinary internal struggle between voluntary and involuntary parts of our life, to learn how well we can deliberately control the outward signs of our inner life.

Vim Segmentation Fault On Mac

2012-02-20T00:00:00+01:00

Ever used the Vim text editor on Mac? If you haven’t, you have at least heard of it. It’s an old, yet amazing and popular piece of software that compiles and runs on practically any OS. As you probably know, it can (and will) greatly increase the productivity of anything text-based you may need to do.

Besides the classical Vim, there’s also a MacVim version for MacOS based on the GUI version of the application, gVim. It offers some conveniences such as Command-S saving, tabs, and a tad bit of a GUI. However, since I spend much of my time on the command line, I much prefer working with classical Vim in iTerm2–more about that another time.

Now, there have been a couple of different situations where I’ve occasionally gotten segmentation faults which killed the Vim process. A nasty problem when you use it as much as I do, especially if you have disabled swap files. The good thing is that these segfaults are easily solved.

Situation 1

Problem: Segmentation fault in Vim after upgrading your OS.

The first time I came across this issue was when I started using Vim, which was after my upgrade to MacOS X Lion. Back then I was simply using Terminal and the pre-installed Vim of MacOS, and I kept getting segmentation faults intermittently for no apparent reason–sometimes when saving files, sometimes when opening them.

It turns out the segmentation faults occured simply because Vim was compiled for Snow Leopard; this is another one we can stack on the pile of reasons why we should always do clean installs of MacOS. The solution is as simple as the problem. Just recompile Vim and it will work happily ever after.

Solution: Recompile Vim, or install it with Homebrew.

# Download Vim 7.3 (latest at the time of writing)
wget ftp://ftp.vim.org/pub/vim/unix/vim-7.3.tar.bz2

# Unpack the archive
tar jxvf vim-7.3.tar.bz2

cd vim-7.3

# Configure (with Ruby support for plugins)
./configure --prefix=/usr/local --enable-rubyinterp --enable-gui=no

# Build and install
make
sudo make install

# Remove the archive
rm -rf vim-7.3.tar.bz2 vim-7.3

# Good to go!

Situation 2

Problem: Segmentation fault when using Ruby plugin.

The second time I got these segmentation faults was when I had installed the Command-T plugin which is written in Ruby. First of all, for the plugin to work it needs Vim to be compiled with Ruby support, which we did above. That however wasn’t the problem that caused the segfaults.

The problem was that the plugin was built and installed with Ruby 1.9.3 which I had installed with RVM. The solution is rather simple this time as well; you just need to use Ruby 1.8.7 as you build the plugin.

Solution: Use Ruby 1.8.7 when building the plugin.

# Switch to system default Ruby. You can also install and
# switch to Ruby 1.8.7 using `rvm (install|use) 1.8.7`.
rvm use system

# We'll assume here that we're dealing with the Command-T
# plugin and you manage it using Pathogen. If you're not
# using Pathogen, `cd` to ~/.vim/ruby/command-t instead.
cd ~/.vim/bundle/command-t/ruby/command-t

# Configure
ruby extconf.rb

# Install
rake make

Conslusion

Vim is a truly amazing piece of software and it has been since 1991, or even since 1976 when Vi was first created. If you spend a reasonable amount of time typing, I recommend that you try if for a week or two. It will be frustrating at first but when you get used to the keyboard mappings and the many great plugins and configurations, I guarantee you, you will be hooked!

Part 2. Writing Nijs JavaScript

2011-11-28T00:00:00+01:00

Last time we talked about JavaScript as a beautiful but often misunderstood language. Today we’ll review our first piece of code; a simple foundation we’ll later add more features to. We’ll start with just a few snippets, simplified from the commented JSLint-valid source available in the GitHub repository.

You can find useful references at the bottom of this post.

First of all, we want to create the object we’ll build upon. But before we do that, we should check if the object already exists (e.g. if we have already declared it in another file.) If it does not exist, we create a Function object just as we normally would declare a function (because that’s essentially what we’re doing.)

if (typeof NI === "undefined") function NI() { };

This first line of code already breaks two of our conventions—always use curly braces when writing if-statements and other code blocks, and always put the opening curly brace on the same line as the statement. Not only does it enhance the readability of our code, it also prevents semi-colon insertion issues¹. We are making an exception here since it’s a very simple one-liner that we want to keep compact and include in other JS files as well.

There are a few more details we should notice here. First of all, we always use the typeof operator when checking for undefined variables, as oopposed to undefined or null. undefined is simply a variable that can be overwritten, meaning our code would break. Second of all, we use the === equality operator instead of ==. We do this because == compares the values after any necessary type conversion. In other words, 0 == '0' would produce true, which in most cases is undesirable.

Finally, as already mentioned, we are declaring NI as a Function instead of using object notation syntax (e.g. var NI = { };. By doing so we can, if necessary, define a constructor, but more importantly, we get access to the prototype property we’ll use next. We could also have written the line like this:

if (typeof NI === "undefined") var NI = function () { };
// or
if (typeof NI === "undefined") var NI = new Function();

// This is the JSLint valid version used in the GitHub repository
var NI = (typeof NI === "undefined") ? function () { "use strict"; } : NI;

Let’s move on to extending the NI object with our first library component—an object called NI.JS that will contain our core functionality.

NI.prototype.JS = (function () {
  /* Core component goes here */
}());

This object will be the core of the library, and unrelated features will be added as separate members of the NI object’s prototype. We are adding it to the prototype since we want it readily available to all instances of NI and those inheriting from it in one way or the other.

Now, if you are new to the module pattern² and prototypal inheritance you may be wondering just what the hell is going on here. It’s actually very straight-forward.

We insert () immediately after the closing curly brace because we want to call the function right away. To make this obvious, we always enclose a self-evoking function in parenthesis, which greatly enhances readability. This means the return value of the function, not the actual function, will be assigned to NI.prototype.JS. The function then acts as a constructor and we don’t need to use the new keyword to instantiate the object.

Let’s add the first core method of the library; a simple shortcut for document.getElementById.

/* Public */
NI.prototype.JS = (function() {
  "use strict";

  /* Private */
  var self = { };

  /* Privileged */
  self.find = function (element) {
    if (!document.getElementById) return false;
    return document.getElementById(element);
  }

  return self;
}

This is a pattern I like to use at the moment for instantiating our object. At the top of the self-evoking function we enable strict mode, introduced in ECMAScript 5. I recommend reading up on strict mode and always using it, but this library will enable it on a per-object basis to keep it optional.

Now to the more interesting parts, starting with a var self = { }; declaration. At that point in the function, self is a private variable. However, the purpose of self is to be returned at the end of the function, effectively exposing it to the public.

By returning self, we can use it to define the public interface of our object. Any method added as a member of self will be privileged, meaning it has access to both public and private variables within its scope³. We could also have written the self-evoking function as follows:

/* Public */
NI.prototype.JS = (function() {
  "use strict";
  
  /* Private variables go here */
  
  return {
    /* Privileged */
    find: function () {
      if(!document.getElementById) return false;
      return document.getElementById(element);
    }
  };
}());

The above function would result in an equivalent object. This is actually a popular and quite nice way of separating private variables and functions from the public interface. However, I prefer defining a public interface using self as it reduces the level of indenting and gives the code a more natural flow. In the end it comes down to personal preference as both produce an equivalent object.

As for the find method, it simply checks if document.getElementById exists and if it does, calls it and returns the resulting element node. Otherwise, we just return false. If we want to be extra picky, we can use the typeof operator to test for both the document (DOM) object and its getElementsById method. We’ll keep it simple for now.

Ideally we should also have only one exit point per function, a convention which we are violating by having multiple return-statements. While conditional one-liners like this one is a farily clean and valid exception, this should be kept in mind.

A minor note; ideally, to be compatible with JSDoc Toolkit, we would comment our private variables and functions with @private, and our public ones with @public. Unfortunately, Pygments which I use for syntax highlighting can’t parse those comments, and neither does JSDoc Toolkit support the @privileged tag.

If we would run this through JSLint, which I suggest you do with any JavaScript code you write, it would give errors. However, most of the errors reported have to do with spacing/indenting and the missing curly braces mentioned earlier—things we do intentionally.

The GitHub repository mentioned in the first paragraph contains the JSLint-valid revision of this code, using the conventions listed below.

That will be all for today—we now have a basic foundation to build upon. If you have any suggestions on how to improve the code or what to do next time, feel free to leave a comment!

Conventions

Always use curly braces.
Always put the opening curly brace on the same line as the statement.
Use the typeof operator when checking for undefined variables.
Avoid type coercion by using === instead of ==.
Always enclose a self-evoking function in parenthesis.
Separate public, privileged and private members for proper encapsulation.
Have one exit point per function, avoiding multiple return-statements.
Validate your code using JSLint.

Footnotes

Part 1. Writing Nijs JavaScript

2011-11-27T00:00:00+01:00

Douglas Crockford tells us that JavaScript is the most misunderstood programming or scripting language available today. I suppose this is because of its popularity among beginners and the seemingly strange and uncommon concept of prototypal inheritance which is at the core of JavaScript, as opposed to the class based approach used in languages like Ruby and PHP.

JavaScript is one of those languages many people either have a hard time fully grasping, or they believe they are proficient enough to not need to learn more about. However, since JavaScript is pretty much the only client-side scripting language running in web browsers these days, it is a great idea to learn more about it. Besides that, JavaScript is actually also a very useful and beautiful object-oriented language that many people underestimate.

To gain a better understanding of how JavaScript works and what the best practices are, and to put that knowledge to good use, I have started writing a library called NI::JS (pronounced “nice”) that will incorporate good conventions and provide a set of helpers/tools for Javascript development.

Of course, there are many libraries already out there. Prototype.js, jQuery, Bootstrap and Ender are just a few examples. It is my opinion that many of these libraries and frameworks tend to over-abstract and obscure JavaScript as a language. Prototype.js for example offers class-based inheritance.

I am not saying that this is necessarily a bad thing. Actually, I enjoy developing with Prototype.js and other libraries. The chaining and abstraction featured in jQuery can be useful, especially to beginners but also to more serious developers.

What I am saying is that I personally like JavaSript as a language and I would like to stick with the prototypal philosophy. That is what this library is all about–embracing the language, and providing conventions and tools to solve common problems. Perhaps this will promote greater knowledge of the fundamentals that many fail to understand.

This post is simply a reminder to myself about my intentions for the NI::JS library. The plan is to build it as I go along, solving problems in a modular way, and posting code reviews on this blog to describe why, and what, I am doing. Hopefully readers will jump in an suggest improvements to the code–I appreciate all suggestions!

So let us begin rocking with JavaScript!

Review Of Day One For Mac And iOS

2011-09-17T00:00:00+02:00

To start off with, let’s just say Day One is a top notch application for both Mac and iOS. That’s enough for this introduction because it’s the simple truth—Day One is a damn great journaling software.

Image copyright Bloom Built, LLC.

When I first heard of Day One, I wanted to compare it to Evernote since they’re both enter-text-daily-and-save-it applications. But I now understand that it’s not a competition between the two of them—they’re two different applications altogether. They may seem similar in many ways but they’ve got completely different purposes in my opinion.

While Evernote is there to catch anything and everything that is on your mind, Day One is more of a pure journaling application. You add entries and they’re organized by their date, simple as that. It’s really simple to use. In fact, what I like most about Day One is that the interface is so much better than Evernote’s—it’s a bliss to use as a journaling software of any kind, no matter if you’re writing a project log book, keeping a diary of your nastiest dreams, or whatever you may want to type down regularly.

One of those small details that I love is that when you launch the app, the first thing you see at the top is an inspirational quote to get you to start writing what’s on your mind. Really love that. You can of course remove it, as well as refresh it to a new quote, but I think it’s a wonderful and unique feature that sets it apart from its competitors. Very cute.

As mentioned, it’s very simple to use. Basically, you’ve got a your calendar with days and entries, and you have your starred entries plus a few reminders. That’s it. That’s what’s in the Twitter-app style sidebar, along with a button for adding a new entry. And that’s kinda the beauty of it all—its simplicity. It seems to be completely designed for daily journaling of any kind—making it as comfortable as possible—beating any competitor that tries to be more.

So what about the Preferences? One awesome thing is that you can enable password protection for you entries, which you may want to do if they’re really private, like mine are sometimes (or maybe I’m just a paranoid IT security freak). You can also enable or disable reminders, setting up when they start and end. General preferences include things like where to keep the database file, whether or not to show the menu bar icon, and a global entry hotkey which is always nice to have, to quickly make a note of anything—again, kinda like Evernote.

At this time and point in it’s lifespan, Day One is very simple to use and in my opinion it’s very targeted towards mere journaling. It can of course be used for much else, but journaling is what it excels at and it’s also what it’s better than Evernote at.

Bottom line, will I replace Evernote with Day One for journaling? I’m not sure. On on hand, I love having everything in one place, and on the other hand I love the interface that Day One offers me. Synchronization is a feature that I really miss, but maybe that’s somewhere down the roadmap.

Day One is really an excellent app for journaling on both Mac and iOS. For that purpose it’s likely the best out there. Let’s just leave it at that!

Link: dayoneapp.com

Meeting People Online Is Easy, Right?

2011-08-28T00:00:00+02:00

The internet has completely changed how many of us meet people. It used to be a matter of a real-life get-together kinda thing, and now it can be a matter of replying to someones blog post or tweet. That changes things substantially but does it really make it all any simpler?

At a first glance at the subject, it seems so. It’s faster and easier to “meet” and become “friends” with someone you’re in contact with over the internet, whether it’s via Facebook, Twitter, Skype or whatever—pick your poison. But do you really, I mean really, get a complete sense of who that person is until you’ve met him or her in person or talked over the phone?

I don’t think so. And that’s where it gets complicated for people like myself who practically hate phones and everything resembling them. Why? Fuck knows. I suppose it’s a feeling of insecurity mixed with control-freakiness.

You don’t know how the person on the other end sounds. If you’re using a webcam, you don’t know how they dress until the moment is right there. You thought you knew it all, and suddenly you don’t know shit, and it’s frightening to some people. Now, is this where I’m supposed to come in and comfort those people and tuck them in?

Fuck that. I used to be, and part of me still am, one of those people that for some stupid-ass reason are nervous about something as natural as human contact, and I say “fuck it, just do it”. I know the last part is trademarked by Nike but I’ve said it so many times it should be trademarked to me by now. Just. Fucking. Do. It. Why? Do you really need me to spell that shit out for you?

OK, then. If you don’t take it from chatting to the phone or webcam, you’ll be stuck without progress when it comes to knowing the person. At some point, you’re gonna need to take it a step further. And what have you really got to lose? I mean, what’s the worst shit that could happen? Rejection? Maybe—but rejection is something you’ve gotta learn how to deal with in life, otherwise you’ll get nowhere, and get nothing or no one.

Truth is also that the person on the other end may be just as frightened as you are, if not more so. Who knows? So just take the fucking chance and do it, OK? Take my word on it; it’s not something you’re likely to regret. I met my first fiancée through the web and I don’t regret meeting her in person—it was fucking amazing, a magic moment never to be forgotten. An angel had fallen from the web and landed right in my lap (literally).

Besides, I’ve always lived by the motto that I’d rather regret something I’ve done than something I haven’t done. Isn’t that a much more fun way to live than ending up 90 years old and regretting the million chances you never took? That’s what I thought. So fuck it, just do it.

As the amazing role-model I am, I’ve taken the first step and set up a Skype date with sweet young Ally on Sunday. It’ll be out of this world, I’m sure of it.

Don Juan of Design and Development

2011-08-25T00:00:00+02:00

The other day Ally again chatted with me on Skype, and the name Don Juan came up for some strange reason. And now… a few days later; I felt I could relate that to web design, development and programming—anything “work” really.

Have you read anything about the tales of Don Juan? I hadn’t, so I Wikipedia-ed the shit out of it and there are loads of information in there. Basically, he’s the world’s greatest lover and he’s a natural born seducer. I can relate to that too but that’s not what I’m talking about.

I’m talking about us, the cyber-maniacs of the web-design-verse. It hit me like a Rolling Stone lick—we are the fucking Don Juan’s of it all. Otherwise, why are you doing what you do, whether it’s designing, programming, or working in a Red Light District booth? We are it.

Do you do it just because "satisfaction" of surviving another pay-day? Then get the fuck out. Seriously. Get. The. Fuck. Out. Because we, right here, we care, and we should be the Don Juan’s of whatever it is we do.

Once upon a time, Steve Jobs—the IT-superhero of the last three decades—so honestly and humbly put it like this:

“We’re here to make a dent in the universe. Otherwise, why even be here?”

As usual, he’s precisely spot on, just like I was when I was competing at the shooting ranges years ago.

If you’ve read this far—have come so far down the lines of text and all that’s in-between—then you’re most likely in it for the love. The love of the game, the life, baby. Congratulations, that’s fantastic, dear!

And I mean that, I really do. Because by being in it for the love of your work—and possibly hate of others work—you’ve gone from 0-60, my friend. It doesn’t matter how fast you got, or will get, there. It’s only that you are there that matters, and nothing else.

Money and the love for it, the greed, or just the necessity of having a job, may get you to 60, that’s for damn sure. It will get you far further too if you have enough of that shit in you. But there’s nothing like being in it for the love, the hate, the opinion-ation of you inner crazy self.

Money is a great motivator—you need it for survival—it’s primal instinct. All-too-natural-mindfuck of the 2000 or so past years.

But it’s not “the real deal”, you know. I’m right now above the clouds, watching the sun set outside my window seat on the plane I’m riding. It’s beautiful to the point of undescribable-ness so I won’t even try. Point is, is your work that beautiful, in your own opinion? If not, do you want it to be?

Then you’re on the right track, baby—your very own track, just where you should be. You’re doing something right; you’re in it for the love. Continue down that path and nobody else’s, and you’re already my own personal idol.

Money is numbers. Love is magic. Do the math, and then continue down your path. Pretty please with cherries on top.

Fuck “show me the money!”—“Show me the love” instead!

@mizwizzy mentioned something on Facebook relating to me and something called “profanity”—had to Google that. Personally, I care about crazy-ass-wise-ass-ness, and throwing in an F-grenade at someone tends to make them think just a lil’ bit more about what you’re saying. My love to you though, Ms. Wizzy! :) And I think this post kinda tuned it down a bit actually, but don’t get used to it!

Wow, this sunset is love(ly). 9.38 PM and about to land but I’ll remain in the clouds because this is a great day, and a great decade for all of us. Rock on.